@sqb/connect 4.10.0 → 4.10.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.10.0",
+  "version": "4.10.2",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>",
@@ -50,7 +50,7 @@
     "@types/lodash": "^4.14.201"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.10.0"
+    "@sqb/builder": "^4.10.2"
   },
   "engines": {
     "node": ">=16.0",
@@ -60,6 +60,7 @@
     "bin/",
     "cjs/",
     "esm/",
+    "types/",
     "LICENSE",
     "README.md"
   ],

package/types/client/adapter.d.ts

@@ -0,0 +1,57 @@
+import { Maybe } from 'ts-gems';
+import { classes } from '@sqb/builder';
+import { ClientConfiguration, DataType, QueryRequest, RowType } from './types.js';
+export interface Adapter {
+    driver: string;
+    dialect: string;
+    features?: {
+        cursor?: boolean;
+        schema?: boolean;
+        fetchAsString?: DataType[];
+    };
+    connect: (config: ClientConfiguration) => Promise<Adapter.Connection>;
+}
+export declare namespace Adapter {
+    interface Connection {
+        sessionId: any;
+        execute: (request: QueryRequest) => Promise<Response>;
+        close: () => Promise<void>;
+        reset: () => Promise<void>;
+        test: () => Promise<void>;
+        startTransaction: () => Promise<void>;
+        setSavepoint?: (savepoint: string) => Promise<void>;
+        releaseSavepoint?: (savepoint: string) => Promise<void>;
+        rollbackSavepoint?: (savepoint: string) => Promise<void>;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        setSchema?: (schema: string) => Promise<void>;
+        getSchema?: () => Promise<string>;
+        onGenerateQuery?: (request: QueryRequest, query: classes.Query) => void;
+        getInTransaction?: () => boolean;
+    }
+    interface Cursor {
+        readonly isClosed: boolean;
+        readonly rowType: RowType;
+        close: () => Promise<void>;
+        fetch: (rows: number) => Promise<Maybe<any[]>>;
+    }
+    interface Response {
+        fields?: Field[];
+        rows?: Record<string, any>[] | any[][];
+        rowType?: RowType;
+        cursor?: Adapter.Cursor;
+        rowsAffected?: number;
+    }
+    interface Field {
+        fieldName: string;
+        dataType: string;
+        jsType: string;
+        isArray?: boolean;
+        elementDataType?: string;
+        nullable?: boolean;
+        fixedLength?: boolean;
+        size?: number;
+        precision?: number;
+        _inf: any;
+    }
+}

package/types/client/cursor-stream.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Cursor } from './cursor.js';
+export interface CursorStreamOptions {
+    objectMode?: boolean;
+    limit?: number;
+}
+declare const inspect: unique symbol;
+export declare class CursorStream extends Readable {
+    private readonly _cursor;
+    private readonly _objectMode?;
+    private readonly _limit;
+    private _rowNum;
+    private _eof;
+    constructor(cursor: Cursor, options?: CursorStreamOptions);
+    /**
+     * Returns if stream is closed.
+     */
+    get isClosed(): boolean;
+    /**
+     * Closes stream and releases the cursor
+     */
+    close(): Promise<void>;
+    toString(): string;
+    [inspect](): string;
+    _read(): void;
+    emit(event: string | symbol, ...args: any[]): boolean;
+}
+export {};

package/types/client/cursor.d.ts

@@ -0,0 +1,116 @@
+import { Adapter } from './adapter.js';
+import { CursorStream, CursorStreamOptions } from './cursor-stream.js';
+import { FieldInfoMap } from './field-info-map.js';
+import { SqbConnection } from './sqb-connection.js';
+import { ObjectRow, QueryRequest } from './types.js';
+interface CursorEvents {
+    close: () => void;
+    error: (error: unknown) => void;
+    eof: () => void;
+    reset: () => void;
+    move: (row: any, rowNum: number) => void;
+    fetch: (row: any, rowNum: number) => void;
+}
+declare const Cursor_base: import("strict-typed-events").Type<import("strict-typed-events").TypedEventEmitter<any, CursorEvents, CursorEvents>>;
+export declare class Cursor extends Cursor_base {
+    private readonly _connection;
+    private readonly _fields;
+    private readonly _prefetchRows;
+    private readonly _request;
+    private _intlcur?;
+    private _taskQueue;
+    private _fetchCache;
+    private _rowNum;
+    private _fetchedAll;
+    private _fetchedRows;
+    private _row;
+    private _cache?;
+    constructor(connection: SqbConnection, fields: FieldInfoMap, adapterCursor: Adapter.Cursor, request: QueryRequest);
+    /**
+     * Returns the Connection instance
+     */
+    get connection(): SqbConnection;
+    /**
+     * Returns if cursor is before first record.
+     */
+    get isBof(): boolean;
+    /**
+     * Returns if cursor is closed.
+     */
+    get isClosed(): boolean;
+    /**
+     * Returns if cursor is after last record.
+     */
+    get isEof(): boolean;
+    /**
+     * Returns number of fetched record count from database.
+     */
+    get fetchedRows(): number;
+    /**
+     * Returns object instance which contains information about fields.
+     */
+    get fields(): FieldInfoMap;
+    /**
+     * Returns current row
+     */
+    get row(): any;
+    /**
+     * Returns current row number.
+     */
+    get rowNum(): number;
+    /**
+     * Enables cache
+     */
+    cached(): void;
+    /**
+     * Closes cursor
+     */
+    close(): Promise<void>;
+    /**
+     * If cache is enabled, this call fetches and keeps all records in the internal cache.
+     * Otherwise it throws error. Once all all records fetched,
+     * you can close Cursor safely and can continue to use it in memory.
+     * Returns number of fetched rows
+     */
+    fetchAll(): Promise<number>;
+    /**
+     * Moves cursor to given row number.
+     * cursor can move both forward and backward if cache enabled.
+     * Otherwise it throws error.
+     */
+    moveTo(rowNum: number): Promise<ObjectRow>;
+    /**
+     * Moves cursor forward by one row and returns that row.
+     * And also it allows iterating over rows easily.
+     */
+    next(): Promise<ObjectRow>;
+    /**
+     *  Moves cursor back by one row and returns that row.
+     *  And also it allows iterating over rows easily.
+     */
+    prev(): Promise<ObjectRow>;
+    /**
+     * Moves cursor before first row. (Required cache enabled)
+     */
+    reset(): void;
+    /**
+     * Moves cursor by given step. If caching is enabled,
+     * cursor can move both forward and backward. Otherwise it throws error.
+     */
+    seek(step: number): Promise<ObjectRow>;
+    /**
+     * Creates and returns a readable stream.
+     */
+    toStream(options?: CursorStreamOptions): CursorStream;
+    toString(): string;
+    inspect(): string;
+    /**
+     *
+     */
+    _seek(step: number, silent?: boolean): Promise<number>;
+    /**
+     *
+     */
+    _fetchRows(): Promise<void>;
+}
+export {};

package/types/client/extensions.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from './adapter.js';
+export declare let adapters: Adapter[];
+export declare function registerAdapter(adapter: Adapter): void;
+export declare function unRegisterAdapter(...adapter: Adapter[]): void;

package/types/client/field-info-map.d.ts

@@ -0,0 +1,12 @@
+import { FieldInfo } from './types.js';
+export declare class FieldInfoMap {
+    private _obj;
+    private _arr;
+    constructor();
+    add(field: FieldInfo): void;
+    get(k: string | number): FieldInfo;
+    entries(): [string, FieldInfo][];
+    keys(): string[];
+    values(): FieldInfo[];
+    toJSON(): Record<string, FieldInfo>;
+}

package/types/client/helpers.d.ts

@@ -0,0 +1,9 @@
+import { Maybe } from 'ts-gems';
+import { Adapter } from './adapter.js';
+import { FieldInfoMap } from './field-info-map.js';
+import { ArrayRowset, FieldNaming, ObjectRowset, QueryRequest } from './types.js';
+export declare function applyNamingStrategy(value: string, namingStrategy?: FieldNaming): Maybe<string>;
+export declare function wrapAdapterFields(oldFields: Adapter.Field[], fieldNaming?: FieldNaming): FieldInfoMap;
+export declare function normalizeRowsToObjectRows(fields: FieldInfoMap, rowType: 'array' | 'object', oldRows: ObjectRowset | ArrayRowset, options?: Pick<QueryRequest, 'ignoreNulls' | 'transform'>): Record<string, any>[];
+export declare function normalizeRowsToArrayRows(fields: FieldInfoMap, rowType: 'array' | 'object', oldRows: ObjectRowset | ArrayRowset, options?: Pick<QueryRequest, 'ignoreNulls' | 'transform'>): any[][];
+export declare function callFetchHooks(rows: ObjectRowset | ArrayRowset, request: QueryRequest): void;

package/types/client/sqb-client.d.ts

@@ -0,0 +1,65 @@
+import { Pool as LightningPool } from 'lightning-pool';
+import { Maybe, Type } from 'ts-gems';
+import { classes } from '@sqb/builder';
+import { Repository } from '../orm/repository.class.js';
+import { SqbConnection } from './sqb-connection.js';
+import { ClientConfiguration, ClientDefaults, ConnectionOptions, QueryExecuteOptions, QueryRequest, QueryResult, TransactionFunction } from './types.js';
+declare const inspect: unique symbol;
+interface SqbClientEvents {
+    execute: (request: QueryRequest) => void;
+    error: (error: Error) => void;
+    closing: () => void;
+    close: () => void;
+    acquire: (connection: SqbConnection) => Promise<void>;
+    terminate: () => void;
+    'connection-return': (connection: SqbConnection) => Promise<void>;
+}
+declare const SqbClient_base: Type<import("strict-typed-events").TypedEventEmitter<any, SqbClientEvents, SqbClientEvents>>;
+export declare class SqbClient extends SqbClient_base {
+    private readonly _adapter;
+    private readonly _pool;
+    private readonly _defaults;
+    private readonly _entities;
+    constructor(config: ClientConfiguration);
+    get defaults(): ClientDefaults;
+    /**
+     * Returns dialect
+     */
+    get dialect(): string;
+    /**
+     * Returns database driver name
+     */
+    get driver(): string;
+    /**
+     * Returns true if pool is closed
+     */
+    get isClosed(): boolean;
+    get pool(): LightningPool;
+    /**
+     * Obtains a connection from the connection pool and executes the callback
+     */
+    acquire(fn: TransactionFunction, options?: ConnectionOptions): Promise<any>;
+    /**
+     * Obtains a connection from the connection pool.
+     */
+    acquire(options?: ConnectionOptions): Promise<SqbConnection>;
+    /**
+     * Shuts down the pool and destroys all resources.
+     */
+    close(terminateWait?: number): Promise<void>;
+    /**
+     * Executes a query or callback with a new acquired connection.
+     */
+    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<QueryResult>;
+    /**
+     * Tests the pool
+     */
+    test(): Promise<void>;
+    getRepository<T>(entity: Type<T> | string, opts?: {
+        schema?: string;
+    }): Repository<T>;
+    getEntity<T>(name: string): Maybe<Type<T>>;
+    toString(): string;
+    [inspect](): string;
+}
+export {};

package/types/client/sqb-connection.d.ts

@@ -0,0 +1,74 @@
+import { Type } from 'ts-gems';
+import { classes } from '@sqb/builder';
+import { Repository } from '../orm/repository.class.js';
+import { Adapter } from './adapter.js';
+import { SqbClient } from './sqb-client.js';
+import { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types.js';
+interface SqbConnectionEvents {
+    close: () => void;
+    execute: (request: QueryRequest) => void;
+    error: (error: Error) => void;
+    retain: (refCount: number) => void;
+    release: (refCount: number) => void;
+    'start-transaction': () => void;
+    'set-savepoint': () => void;
+    'release-savepoint': () => void;
+    'rollback-savepoint': () => void;
+    commit: () => void;
+    rollback: () => void;
+}
+declare const SqbConnection_base: Type<import("strict-typed-events").TypedEventEmitter<any, SqbConnectionEvents, SqbConnectionEvents>>;
+export declare class SqbConnection extends SqbConnection_base {
+    readonly client: SqbClient;
+    private _intlcon?;
+    private readonly _tasks;
+    private readonly _options?;
+    private _inTransaction;
+    private _refCount;
+    constructor(client: SqbClient, adapterConnection: Adapter.Connection, options?: ConnectionOptions);
+    /**
+     * Returns session id
+     */
+    get sessionId(): string;
+    /**
+     * Returns reference counter value
+     */
+    get refCount(): number;
+    /**
+     * Returns true if transaction started
+     */
+    get inTransaction(): boolean;
+    /**
+     * Increases internal reference counter to keep session alive
+     */
+    retain(): void;
+    /**
+     * Decreases the internal reference counter.
+     * When reference count is 0, connection returns to the pool.
+     * Returns true if connection released.
+     */
+    release(): boolean;
+    /**
+     * Immediately releases the connection.
+     */
+    close(): Promise<void>;
+    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
+    getRepository<T>(entity: Type<T> | string, opts?: {
+        schema?: string;
+    }): Repository<T>;
+    getSchema(): Promise<string>;
+    setSchema(schema: string): Promise<void>;
+    /**
+     * Executes a query
+     */
+    protected _execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
+    startTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    setSavepoint(savepoint: string): Promise<void>;
+    releaseSavepoint(savepoint: string): Promise<void>;
+    rollbackSavepoint(savepoint: string): Promise<void>;
+    test(): Promise<void>;
+    private _prepareQueryRequest;
+}
+export {};

package/types/client/types.d.ts

@@ -0,0 +1,181 @@
+import type { PoolConfiguration } from 'lightning-pool';
+import { Maybe } from 'ts-gems';
+import { DataType, ParamOptions } from '@sqb/builder';
+import type { Adapter } from './adapter';
+import type { Cursor } from './cursor';
+import type { FieldInfoMap } from './field-info-map';
+import type { SqbConnection } from './sqb-connection';
+export { DataType } from '@sqb/builder';
+export type ExecuteHookFunction = (connection: SqbConnection, request: QueryRequest) => Promise<void>;
+export type FetchFunction = (row: any, request: QueryRequest) => void;
+export type ValueTransformFunction = (value: any, fieldInfo?: FieldInfo) => any;
+export type TransactionFunction = (connection: SqbConnection) => Promise<any>;
+export type RowType = 'array' | 'object';
+export type FieldNaming = 'original' | 'lowercase' | 'uppercase' | 'camelcase' | 'pascalcase' | ((fieldName: string) => Maybe<string>);
+export type ObjectRow = Record<string, any>;
+export type ArrayRow = any[];
+export type ObjectRowset = ObjectRow[];
+export type ArrayRowset = ArrayRow[];
+export interface ClientConfiguration {
+    /**
+     * Dialect to be used
+     */
+    dialect?: string;
+    /**
+     * Database connection driver to be used
+     */
+    driver?: string;
+    /**
+     * Connection name
+     */
+    name?: string;
+    /**
+     * Database server address or url
+     */
+    host?: string;
+    /**
+     * Database listener port number
+     *
+     */
+    port?: number;
+    /**
+     * Database username.
+     */
+    user?: string;
+    /**
+     * Database password.
+     */
+    password?: string;
+    /**
+     * Database name
+     */
+    database?: string;
+    /**
+     * Database schema
+     */
+    schema?: string;
+    /**
+     * Connection options to be passed to the underlying driver
+     */
+    driverOptions?: any;
+    /**
+     * Pooling options
+     */
+    pool?: PoolConfiguration;
+    /**
+     * Default options
+     */
+    defaults?: ClientDefaults;
+}
+export interface ClientDefaults {
+    autoCommit?: boolean;
+    cursor?: boolean;
+    objectRows?: boolean;
+    fieldNaming?: FieldNaming;
+    showSql?: boolean;
+    prettyPrint?: boolean;
+    ignoreNulls?: boolean;
+    /**
+     * Sets how many row will be fetched at a time
+     * Default = 10
+     */
+    fetchRows?: number;
+    transform?: ValueTransformFunction;
+}
+export interface ConnectionOptions {
+    /**
+     *  If this property is true, the transaction committed at the end of query execution.
+     *  Default = false
+     */
+    autoCommit?: boolean;
+}
+export interface QueryExecuteOptions {
+    /**
+     * Array of values or object that contains param/value pairs.
+     */
+    params?: Record<string, any> | any[];
+    /**
+     *  If this property is true, the transaction committed at the end of query execution.
+     *  Default = false
+     */
+    autoCommit?: boolean;
+    /**
+     * If this property is true, query returns a Cursor object that works
+     * in unidirectional "cursor" mode.
+     * Important! Cursor keeps connection open until cursor.close() method is called.
+     */
+    cursor?: boolean;
+    /**
+     * Function for converting data before returning response.
+     */
+    transform?: ValueTransformFunction;
+    /**
+     * In "cursor" mode; it provides an initial suggested number of rows to prefetch.
+     * Prefetching is a tuning option to maximize data transfer efficiency and
+     * minimize round-trips to the database. In regular mode;
+     * it provides the maximum number of rows that are fetched from Connection instance.
+     * Default = 10
+     */
+    fetchRows?: number;
+    /**
+     * If set true, NULL fields will be ignored
+     * Default = false
+     */
+    ignoreNulls?: boolean;
+    /**
+     * Sets the naming strategy for fields. It affects field names in object rows and metadata
+     */
+    namingStrategy?: FieldNaming;
+    /**
+     * Determines whether query rows should be returned as Objects or Arrays.
+     * This property applies to ResultSet.objectRows property also.
+     * Default = driver default
+     */
+    objectRows?: boolean;
+    /**
+     * If set true, result object contains executed sql and values.
+     * Default = false
+     */
+    showSql?: boolean;
+    prettyPrint?: boolean;
+    action?: string;
+    fetchAsString?: DataType[];
+}
+export interface QueryResult {
+    executeTime: number;
+    fields?: FieldInfoMap;
+    rows?: any;
+    rowType?: RowType;
+    query?: QueryRequest;
+    returns?: any;
+    rowsAffected?: number;
+    cursor?: Cursor;
+}
+export type FieldInfo = {
+    index: number;
+    name: string;
+} & Adapter.Field;
+export interface QueryRequest {
+    dialect?: string;
+    dialectVersion?: string;
+    sql: string;
+    params?: any;
+    paramOptions?: Record<string, ParamOptions> | ParamOptions[];
+    returningFields?: {
+        field: string;
+        alias?: string;
+    }[];
+    autoCommit?: boolean;
+    cursor?: boolean;
+    objectRows?: boolean;
+    ignoreNulls?: boolean;
+    fetchRows?: number;
+    fieldNaming?: FieldNaming;
+    transform?: ValueTransformFunction;
+    showSql?: boolean;
+    prettyPrint?: boolean;
+    action?: string;
+    fetchAsString?: DataType[];
+    executeHooks?: ExecuteHookFunction[];
+    fetchHooks?: FetchFunction[];
+}

package/types/index.d.ts

@@ -0,0 +1,34 @@
+import 'reflect-metadata';
+import { DeepBuildable, DeepPartial, DeepPickWritable, Maybe, Type } from 'ts-gems';
+export { Type, Maybe, DeepPartial, DeepPickWritable, DeepBuildable };
+export * from './types.js';
+export * from './client/types.js';
+export * from './client/adapter.js';
+export * from './client/sqb-client.js';
+export * from './client/sqb-connection.js';
+export * from './client/cursor.js';
+export { registerAdapter, unRegisterAdapter } from './client/extensions.js';
+export * from './orm/orm.type.js';
+export * from './orm/orm.const.js';
+export * from './orm/base-entity.js';
+export * from './orm/repository.class.js';
+export * from './orm/model/entity-metadata.js';
+export * from './orm/model/field-metadata.js';
+export * from './orm/model/column-field-metadata.js';
+export * from './orm/model/embedded-field-metadata.js';
+export * from './orm/model/association-field-metadata.js';
+export * from './orm/model/association.js';
+export * from './orm/model/association-node.js';
+export * from './orm/model/index-metadata.js';
+export * from './orm/model/link-chain.js';
+export * from './orm/decorators/column.decorator.js';
+export * from './orm/decorators/embedded.decorator.js';
+export * from './orm/decorators/entity.decorator.js';
+export * from './orm/decorators/events.decorator.js';
+export * from './orm/decorators/foreignkey.decorator.js';
+export * from './orm/decorators/index.decorator.js';
+export * from './orm/decorators/link.decorator.js';
+export * from './orm/decorators/primarykey.decorator.js';
+export * from './orm/decorators/transform.decorator.js';
+export { isColumnField, isEmbeddedField, isAssociationField, isEntityClass } from './orm/util/orm.helper.js';
+export * from './orm/backward.js';

package/types/orm/backward.d.ts

@@ -0,0 +1,13 @@
+import { PickWritable, Type } from 'ts-gems';
+import { Entity } from './decorators/entity.decorator.js';
+export declare function getInsertColumnNames<T, K extends keyof PickWritable<T>>(ctor: Type<T>): K[];
+export declare function getUpdateColumnNames<T, K extends keyof PickWritable<T>>(ctor: Type<T>): K[];
+export declare function getNonAssociationElementNames<T, K extends keyof PickWritable<T>>(ctor: Type<T>): K[];
+export declare function mixinEntities<A, B>(derivedCtor: Type<A>, baseB: Type<B>): Type<A & B>;
+export declare function mixinEntities<A, B, C>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
+export declare function mixinEntities<A, B, C, D>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
+export declare function mixinEntities<A, B, C, D, E>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
+export declare function mixinEntities<A, B, C, D, E, F>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
+export declare const OmitEntity: typeof Entity.Omit;
+export declare const PickEntity: typeof Entity.Pick;
+export declare const UnionEntity: typeof Entity.Union;

package/types/orm/base-entity.d.ts

@@ -0,0 +1,8 @@
+import { REPOSITORY_KEY } from './orm.const.js';
+export declare class BaseEntity {
+    private [REPOSITORY_KEY]?;
+    constructor(partial?: any);
+    destroy(): Promise<boolean>;
+    exists(): Promise<boolean>;
+    toJSON(): any;
+}

package/types/orm/commands/command.helper.d.ts

@@ -0,0 +1,14 @@
+import { JoinStatement, LogicalOperator } from '@sqb/builder';
+import { AssociationNode } from '../model/association-node.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+export interface JoinInfo {
+    association: AssociationNode;
+    sourceEntity: EntityMetadata;
+    targetEntity: EntityMetadata;
+    joinAlias: string;
+    join: JoinStatement;
+}
+export declare function joinAssociationGetFirst(joinInfos: JoinInfo[], association: AssociationNode, parentAlias: string, innerJoin?: boolean): Promise<JoinInfo>;
+export declare function joinAssociationGetLast(joinInfos: JoinInfo[], association: AssociationNode, parentAlias: string, innerJoin?: boolean): Promise<JoinInfo>;
+export declare function joinAssociation(joinInfos: JoinInfo[], association: AssociationNode, parentAlias: string, innerJoin?: boolean): Promise<JoinInfo[]>;
+export declare function prepareFilter(entityDef: EntityMetadata, filter: any, trgOp: LogicalOperator, tableAlias?: string): Promise<void>;

package/types/orm/commands/count.command.d.ts

@@ -0,0 +1,11 @@
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
+export type CountCommandArgs = {
+    entity: EntityMetadata;
+    connection: SqbConnection;
+} & Repository.CountOptions;
+export declare class CountCommand {
+    protected constructor();
+    static execute(args: CountCommandArgs): Promise<number>;
+}