ts-prorm-orm 1.1.0 → 1.2.1

package/dist/nosql/gearman/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Gearman job-server store.
+ *
+ * Gearman is a generic application framework for farming out work: a *client*
+ * submits a job for a named function, the Gearman *job server* routes it to a
+ * *worker* that has registered a handler for that function, and the result
+ * flows back. It is not a database and does not fit the SQL-shaped `Dialect`
+ * interface, so this class implements the minimal `NoSqlStore` marker
+ * interface and exposes Gearman's real submit/register operations instead.
+ *
+ * Uses the `gearman` driver. It is an optional peer loaded lazily (via
+ * `require`) inside `connect()`, so importing this module does not require it
+ * to be installed unless you actually connect. A pre-built client can be
+ * injected via `GearmanStoreOptions.client`, in which case `connect()` adopts
+ * it and skips the `require` entirely (used by the unit tests to inject a
+ * mock).
+ */
+import type { NoSqlStore } from '../store';
+/** Connection options for `GearmanStore`. */
+export interface GearmanStoreOptions {
+    /** Gearman job-server host. Defaults to `'127.0.0.1'`. */
+    host?: string;
+    /** Gearman job-server port. Defaults to `4730`. */
+    port?: number;
+    /**
+     * A pre-built `gearman` client. When provided, `connect()` adopts it and
+     * does not `require('gearman')` — used for injecting a mock in tests.
+     */
+    client?: any;
+}
+/** Options for `enqueue()` (submitting a job). */
+export interface GearmanSubmitOptions {
+    /** Submit as a background job (fire-and-forget, no result callback). */
+    background?: boolean;
+    /** Job priority: `'high'`, `'normal'` (default), or `'low'`. */
+    priority?: 'high' | 'normal' | 'low';
+}
+/**
+ * `GearmanStore` wraps a single `gearman` client and exposes the common queue
+ * surface over Gearman functions: `enqueue()` submits a job, `process()`
+ * registers a worker handler, and job status/removal/stats route to the
+ * driver's corresponding calls.
+ */
+export declare class GearmanStore implements NoSqlStore {
+    readonly name = "gearman";
+    readonly library = "gearman";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: GearmanStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `gearman` client for operations not wrapped here. */
+    getClient(): any;
+    private requireClient;
+    private exec;
+    /**
+     * Submit a job for the named function (`queue`). The payload is
+     * JSON-serialized (strings pass through). Returns the job handle/id the
+     * server assigns (`job.handle` if the driver returns a job object).
+     */
+    enqueue(queue: string, jobData: unknown, opts?: GearmanSubmitOptions): Promise<string>;
+    /**
+     * Register a worker handler for the named function (`queue`). The driver
+     * invokes `handler(job)` for each dispatched task. Falls back to
+     * `addFunction()` when the driver has no `registerWorker()`.
+     */
+    process(queue: string, handler: (job: any) => void | Promise<void>): Promise<void>;
+    /** Query the status of a submitted job by its handle/id. */
+    getJob(_queue: string, id: string): Promise<any>;
+    /** Cancel/forget a submitted job by its handle/id. */
+    remove(_queue: string, id: string): Promise<any>;
+    /** Return job-server status (registered functions, queued/running counts). */
+    stats(_queue?: string): Promise<any>;
+}
+export default GearmanStore;

package/dist/nosql/geode/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Apache Geode store implementation.
+ *
+ * Apache Geode (the engine behind Pivotal/VMware GemFire) is a distributed
+ * in-memory data grid. Data lives in named *regions* (its distributed maps).
+ * There is no SQL-shaped `query(sql)` surface for key/value access, so this
+ * class implements the minimal `NoSqlStore` marker interface and exposes
+ * Geode's region operations (getMap/put/get/remove/keys/size) as a typed,
+ * promise-based API.
+ *
+ * ## Transport: the Geode Developer REST API over `fetch`
+ *
+ * Geode has no canonical Node.js driver; it ships a language-neutral
+ * "Developer REST API". This store talks to it with the global `fetch`
+ * (exactly like `PrometheusStore`), so `library` is `'fetch'`. For tests
+ * (and callers who want their own transport) an alternative client can be
+ * injected via `GeodeStoreOptions.client`; when omitted a tiny internal
+ * `fetch` client is built at connect time.
+ *
+ * Endpoints wrapped (all under `/geode/v1`):
+ * - `mapPut`    -> `PUT    /geode/v1/<region>/<key>`
+ * - `mapGet`    -> `GET    /geode/v1/<region>/<key>`
+ * - `mapRemove` -> `DELETE /geode/v1/<region>/<key>`
+ * - `mapKeys`   -> `GET    /geode/v1/<region>/keys`
+ * - `mapSize`   -> derived from `mapKeys` (the Developer REST API exposes no
+ *                  direct size endpoint)
+ */
+import { NoSqlStore } from '../store';
+/** Default Geode Developer REST API base URL. */
+export declare const DEFAULT_GEODE_BASE_URL = "http://localhost:8080";
+/**
+ * The subset of an HTTP client this store needs. The internal `fetch`-based
+ * client implements this; tests inject a mock with the same shape.
+ */
+export interface GeodeHttpClient {
+    /** GET `path`; return the parsed body, or `null` on 404. */
+    get(path: string): Promise<any>;
+    /** PUT `body` to `path`. */
+    put(path: string, body: string, contentType?: string): Promise<any>;
+    /** DELETE `path`. */
+    delete(path: string): Promise<any>;
+}
+/** A resolved region handle. `getMap(name)` returns one; the `map*` methods consume it. */
+export interface GeodeRegion {
+    readonly name: string;
+}
+/** Connection options for `GeodeStore`. */
+export interface GeodeStoreOptions {
+    /** Base URL of the Geode REST server. Defaults to `http://localhost:8080`. */
+    baseURL?: string;
+    /** Pre-built HTTP client; when given it is used verbatim and `baseURL` is ignored. */
+    client?: GeodeHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Build a `fetch`-backed REST client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): GeodeHttpClient;
+/**
+ * `GeodeStore` wraps Geode's Developer REST API behind the `NoSqlStore`
+ * lifecycle and exposes named-region key/value operations.
+ */
+export declare class GeodeStore implements NoSqlStore {
+    readonly name = "geode";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    /** Cached region handles, keyed by name so `getMap` is idempotent. */
+    private readonly regions;
+    constructor(options?: GeodeStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): GeodeHttpClient;
+    private requireClient;
+    private wrap;
+    /** Resolve (and cache) a named-region handle. */
+    getMap(name: string): Promise<GeodeRegion>;
+    /** Store `value` under `key` in `map` (`PUT /geode/v1/<region>/<key>`). */
+    mapPut(map: GeodeRegion, key: string, value: unknown): Promise<void>;
+    /** Read `key` from `map` (`GET /geode/v1/<region>/<key>`); `null` if absent. */
+    mapGet(map: GeodeRegion, key: string): Promise<any>;
+    /** Remove `key` from `map` (`DELETE /geode/v1/<region>/<key>`). */
+    mapRemove(map: GeodeRegion, key: string): Promise<any>;
+    /** List all keys in `map` (`GET /geode/v1/<region>/keys`). */
+    mapKeys(map: GeodeRegion): Promise<any[]>;
+    /** Number of entries in `map` (derived from `mapKeys`). */
+    mapSize(map: GeodeRegion): Promise<number>;
+}
+export default GeodeStore;

package/dist/nosql/graphdb/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Ontotext GraphDB store implementation.
+ *
+ * GraphDB is an RDF triplestore that speaks the SPARQL 1.1 Protocol over HTTP.
+ * A repository exposes a query endpoint (`/repositories/<repo>`) and an update
+ * endpoint (`/repositories/<repo>/statements`). There is no SQL-shaped surface
+ * (no rows, no DDL, no identifier escaping), so it implements the minimal
+ * `NoSqlStore` marker interface (`src/nosql/store.ts`) rather than the SQL
+ * `Dialect` interface.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * GraphDB has no dedicated npm client; it is just a SPARQL/HTTP endpoint. This
+ * store talks to the server with the global `fetch`. For tests (and for
+ * callers who want their own transport) an alternative client can be injected
+ * via `GraphdbStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `endpoint` is built at connect time.
+ *
+ * ## Surface
+ *
+ * - `query(sparql)`  -> POST to `/repositories/<repo>`, returns bindings
+ * - `update(sparql)` -> POST to `/repositories/<repo>/statements`
+ * - `ask(sparql)`    -> POST an ASK query, returns the boolean
+ * - `add(triples)`   -> `INSERT DATA { ... }` update
+ * - `drop(graph?)`   -> `DROP GRAPH <g>` / `DROP ALL` update
+ */
+import { NoSqlStore } from '../store';
+/** Default GraphDB base URL. */
+export declare const DEFAULT_GRAPHDB_ENDPOINT = "http://localhost:7200";
+/** Default repository id. */
+export declare const DEFAULT_GRAPHDB_REPOSITORY = "repo";
+/** The subset of a SPARQL HTTP client this store needs. */
+export interface SparqlHttpClient {
+    /** POST a SPARQL query to `path`; returns the parsed results envelope. */
+    query(path: string, sparql: string): Promise<any>;
+    /** POST a SPARQL update to `path`. */
+    update(path: string, sparql: string): Promise<any>;
+}
+/** Connection options for `GraphdbStore`. */
+export interface GraphdbStoreOptions {
+    /** Base URL of the GraphDB server. Defaults to `http://localhost:7200`. */
+    endpoint?: string;
+    /** Repository id. Defaults to `repo`. */
+    repository?: string;
+    /** Optional pre-built SPARQL HTTP client (used verbatim; `endpoint` ignored). */
+    client?: SparqlHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Build a `fetch`-backed SPARQL client for the given endpoint. */
+export declare function createFetchClient(endpoint: string, headers?: Record<string, string>): SparqlHttpClient;
+/**
+ * `GraphdbStore` wraps a GraphDB repository's SPARQL query/update endpoints
+ * behind the `NoSqlStore` lifecycle.
+ */
+export declare class GraphdbStore implements NoSqlStore {
+    readonly name = "graphdb";
+    readonly library = "fetch";
+    private readonly endpoint;
+    private readonly repository;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: GraphdbStoreOptions);
+    /** SPARQL query endpoint path for the configured repository. */
+    get queryPath(): string;
+    /** SPARQL update endpoint path for the configured repository. */
+    get updatePath(): string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) SPARQL HTTP client. */
+    getClient(): SparqlHttpClient;
+    private requireClient;
+    /** Runs a SPARQL SELECT/CONSTRUCT query; returns the result bindings. */
+    query(sparql: string): Promise<any[]>;
+    /** Runs a SPARQL ASK query; returns the boolean answer. */
+    ask(sparql: string): Promise<boolean>;
+    /** Runs a SPARQL UPDATE (INSERT/DELETE/DROP/...). */
+    update(sparql: string): Promise<any>;
+    /** Inserts triples via `INSERT DATA { ... }`. Accepts a triple string or array. */
+    add(triples: string | string[], graph?: string): Promise<any>;
+    /** Drops a named graph, or all graphs when no graph is given. */
+    drop(graph?: string): Promise<any>;
+}

package/dist/nosql/graylog/index.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Graylog store implementation.
+ *
+ * Graylog is a centralized log-management platform. Logs are ingested in the
+ * GELF (Graylog Extended Log Format) over an HTTP input, and searched via
+ * the REST universal search API. There is no SQL-shaped query surface, no
+ * row-level UPDATE/DELETE, and no identifier escaping, so Graylog does not
+ * fit the SQL `Dialect` interface (`src/dialects/dialect.ts`). This class
+ * implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes Graylog's ingest/search API.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Graylog has no single canonical npm client; it is an HTTP/JSON API. This
+ * store talks to it with the global `fetch` (so `library` is `'fetch'`). For
+ * tests (and custom transports) an alternative HTTP client can be injected
+ * via `GraylogStoreOptions.client`.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(host, entries)` -> `POST /gelf`  (GELF ingest, one message per entry)
+ * - `query(q, opts?)`     -> `GET  /api/search/universal/relative`  (search)
+ * - `labels()`            -> `GET  /api/system/fields`  (message field names)
+ * - `streams()`           -> `GET  /api/streams`  (configured streams)
+ */
+import { NoSqlStore } from '../store';
+/** Default Graylog HTTP base URL (GELF HTTP input on 12201, REST on 9000). */
+export declare const DEFAULT_GRAYLOG_BASE_URL = "http://localhost:9000";
+/** Query-string parameter value(s). `undefined` values are dropped. */
+export type QueryParams = Record<string, string | string[] | undefined>;
+/**
+ * The subset of an HTTP client this store needs. The internal `fetch`-based
+ * client implements this; tests inject a mock with the same shape.
+ */
+export interface GraylogHttpClient {
+    /** Issue a GET and return the parsed JSON response body. */
+    get(path: string, params?: QueryParams): Promise<any>;
+    /** Issue a POST with a text body and return the parsed JSON/text response. */
+    post(path: string, body: string, contentType?: string): Promise<any>;
+}
+/** Connection options for `GraylogStore`. */
+export interface GraylogStoreOptions {
+    /** Base URL of the Graylog REST API. Defaults to `http://localhost:9000`. */
+    baseURL?: string;
+    /**
+     * Optional pre-built HTTP client. When provided it is used verbatim and
+     * `baseURL` is ignored; otherwise an internal `fetch`-based client is
+     * built against `baseURL` on `connect()`.
+     */
+    client?: GraylogHttpClient;
+    /** Extra HTTP headers (e.g. `Authorization`) sent with every request. */
+    headers?: Record<string, string>;
+}
+/** A GELF log message. `short_message` is required by the format. */
+export interface GraylogEntry {
+    short_message: string;
+    full_message?: string;
+    /** Unix seconds (with optional fractional ms). Defaults to now on the server if omitted. */
+    timestamp?: number;
+    /** Syslog level 0-7. */
+    level?: number;
+    /** Any additional structured fields (prefixed with `_` in GELF). */
+    [field: string]: unknown;
+}
+/** Options for a relative universal search. */
+export interface GraylogQueryOptions {
+    /** Relative search range in seconds (how far back from now). Defaults to 300. */
+    range?: number;
+    /** Max number of messages to return. */
+    limit?: number;
+    /** Offset into the result set. */
+    offset?: number;
+    /** Sort spec, e.g. `timestamp:desc`. */
+    sort?: string;
+    /** Restrict the search to a specific stream ID. */
+    filter?: string;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): GraylogHttpClient;
+/**
+ * `GraylogStore` wraps Graylog's GELF HTTP ingest input and its REST
+ * universal-search / metadata API behind the `NoSqlStore` lifecycle.
+ */
+export declare class GraylogStore implements NoSqlStore {
+    readonly name = "graylog";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: GraylogStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): GraylogHttpClient;
+    private requireClient;
+    private doGet;
+    /**
+     * Ingests one or more log entries as GELF messages via `POST /gelf`. Each
+     * entry is completed into a GELF `1.1` message with the shared `host`, and
+     * messages are newline-delimited (the GELF HTTP input accepts one JSON
+     * message per line).
+     */
+    push(host: string, entries: GraylogEntry[]): Promise<any>;
+    /**
+     * Runs a relative universal search via
+     * `GET /api/search/universal/relative`. Returns the parsed response
+     * (`{ messages, total_results, fields, ... }`).
+     */
+    query(q: string, options?: GraylogQueryOptions): Promise<any>;
+    /** Lists the known message field names via `GET /api/system/fields`. */
+    labels(): Promise<any>;
+    /** Lists the configured streams via `GET /api/streams`. */
+    streams(): Promise<any>;
+}
+export default GraylogStore;

package/dist/nosql/gridgain/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * GridGain store implementation.
+ *
+ * GridGain is the commercial in-memory computing platform built on (and
+ * wire-compatible with) Apache Ignite: it speaks the same thin-client
+ * protocol and exposes the same distributed key/value caches. Consequently
+ * this store uses the very same `apache-ignite-client` Node.js thin-client
+ * driver as `IgniteStore`, differing only in `name` ('gridgain') and the
+ * error/message labels. Like Ignite it targets the distributed-cache
+ * (key/value grid) surface rather than SQL, so it implements the minimal
+ * `NoSqlStore` marker interface and exposes cache operations
+ * (getCache/put/get/removeKey/getKeys/getSize) as a typed, promise-based API.
+ *
+ * The driver is loaded lazily inside `connect()` (or supplied pre-built via
+ * the `client` option) so importing this module never requires
+ * `apache-ignite-client` to be installed unless a GridGain store is actually
+ * connected. Tests inject a mock client this way.
+ */
+import { NoSqlStore } from '../store';
+/** The subset of an Ignite/GridGain thin-client `CacheClient` this store drives. */
+export interface GridGainCache {
+    put(key: unknown, value: unknown): Promise<unknown>;
+    get(key: unknown): Promise<unknown>;
+    removeKey(key: unknown): Promise<boolean>;
+    getKeys(): Promise<unknown[]>;
+    getSize(): Promise<number>;
+}
+/** The subset of the `apache-ignite-client` `IgniteClient` surface this store drives. */
+export interface GridGainClientLike {
+    connect(config: unknown): Promise<void>;
+    disconnect(): void | Promise<void>;
+    getCache(name: string): GridGainCache | Promise<GridGainCache>;
+}
+/** Connection options for `GridGainStore`. */
+export interface GridGainStoreOptions {
+    /**
+     * One or more `host:port` thin-client endpoints (default
+     * `['127.0.0.1:10800']`). Passed to `new IgniteClientConfiguration(...)`.
+     * Ignored when a pre-built `client` is supplied.
+     */
+    endpoints?: string[];
+    /** Pre-built GridGain/Ignite client; when given, `connect()` uses it and skips the `require`. */
+    client?: GridGainClientLike;
+}
+/**
+ * `GridGainStore` wraps an `apache-ignite-client` client (GridGain is
+ * Ignite-based and shares the thin-client protocol) and exposes its
+ * distributed-cache operations as a typed, promise-based API.
+ */
+export declare class GridGainStore implements NoSqlStore {
+    readonly name = "gridgain";
+    readonly library = "apache-ignite-client";
+    private readonly options;
+    private client;
+    private connected;
+    /** Resolved `CacheClient` handles, cached by name so `getMap` is idempotent. */
+    private readonly caches;
+    constructor(options?: GridGainStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `apache-ignite-client` client for anything not wrapped here. */
+    getClient(): GridGainClientLike;
+    private requireClient;
+    /** Resolve (and cache) a distributed cache handle by name. */
+    getMap(name: string): Promise<GridGainCache>;
+    /** Put `value` under `key` in `map` (a GridGain cache handle). */
+    mapPut(map: GridGainCache, key: unknown, value: unknown): Promise<unknown>;
+    /** Get the value stored under `key` in `map` (or null if absent). */
+    mapGet(map: GridGainCache, key: unknown): Promise<unknown>;
+    /** Remove `key` from `map`. Returns GridGain's boolean success flag. */
+    mapRemove(map: GridGainCache, key: unknown): Promise<boolean>;
+    /** Return all keys currently in `map` as an array. */
+    mapKeys(map: GridGainCache): Promise<unknown[]>;
+    /** Return the number of entries in `map`. */
+    mapSize(map: GridGainCache): Promise<number>;
+}
+export default GridGainStore;

package/dist/nosql/hazelcast/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Hazelcast store implementation.
+ *
+ * Hazelcast is a distributed in-memory data grid (IMDG). Its central data
+ * structure is the distributed `IMap` - a partitioned, replicated key/value
+ * map spread across cluster members. It has no SQL-shaped `query(sql)`
+ * surface, so this class implements the minimal `NoSqlStore` marker
+ * interface and exposes Hazelcast's distributed-map operations
+ * (getMap/put/get/remove/keySet/size) as a typed, promise-based API.
+ *
+ * Uses the `hazelcast-client` driver. The driver is loaded lazily inside
+ * `connect()` (or supplied pre-built via the `client` option) so importing
+ * this module never requires `hazelcast-client` to be installed unless a
+ * Hazelcast store is actually connected. Tests inject a mock client this way.
+ */
+import { NoSqlStore } from '../store';
+/** The subset of a Hazelcast `IMap` handle this store drives. */
+export interface HazelcastMap {
+    put(key: unknown, value: unknown): Promise<unknown>;
+    get(key: unknown): Promise<unknown>;
+    remove(key: unknown): Promise<unknown>;
+    keySet(): Promise<unknown[]>;
+    size(): Promise<number>;
+}
+/** The subset of the `hazelcast-client` `Client` surface this store drives. */
+export interface HazelcastClientLike {
+    getMap(name: string): Promise<HazelcastMap>;
+    shutdown(): Promise<void> | void;
+}
+/** Connection options for `HazelcastStore`. */
+export interface HazelcastStoreOptions {
+    /**
+     * Hazelcast client config passed straight through to
+     * `Client.newHazelcastClient(config)` (cluster name, network member
+     * addresses, etc). Ignored when a pre-built `client` is supplied.
+     */
+    config?: Record<string, unknown>;
+    /** Pre-built Hazelcast client; when given, `connect()` uses it and skips `require('hazelcast-client')`. */
+    client?: HazelcastClientLike;
+}
+/**
+ * `HazelcastStore` wraps a `hazelcast-client` `Client` and exposes its
+ * distributed `IMap` operations as a typed, promise-based API.
+ */
+export declare class HazelcastStore implements NoSqlStore {
+    readonly name = "hazelcast";
+    readonly library = "hazelcast-client";
+    private readonly options;
+    private client;
+    private connected;
+    /** Resolved `IMap` handles, cached by map name so `getMap` is idempotent. */
+    private readonly maps;
+    constructor(options?: HazelcastStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `hazelcast-client` client for anything not wrapped here. */
+    getClient(): HazelcastClientLike;
+    private requireClient;
+    /** Resolve (and cache) a distributed `IMap` handle by name. */
+    getMap(name: string): Promise<HazelcastMap>;
+    /** Put `value` under `key` in `map`, returning the previous value (or null). */
+    mapPut(map: HazelcastMap, key: unknown, value: unknown): Promise<unknown>;
+    /** Get the value stored under `key` in `map` (or null if absent). */
+    mapGet(map: HazelcastMap, key: unknown): Promise<unknown>;
+    /** Remove `key` from `map`, returning the removed value (or null). */
+    mapRemove(map: HazelcastMap, key: unknown): Promise<unknown>;
+    /** Return all keys currently in `map` as an array. */
+    mapKeys(map: HazelcastMap): Promise<unknown[]>;
+    /** Return the number of entries in `map`. */
+    mapSize(map: HazelcastMap): Promise<number>;
+}
+export default HazelcastStore;

package/dist/nosql/hbase/index.d.ts

@@ -0,0 +1,123 @@
+import type { NoSqlStore } from '../store';
+/** A map of `'family:qualifier'` column keys to cell values for a single row. */
+export type HBaseRowData = Record<string, unknown>;
+/**
+ * Minimal structural type for the fluent `row(key)` handle the `hbase` driver
+ * returns. Each method takes a Node-style `(err, result)` callback; this store
+ * promisifies them.
+ */
+export interface HBaseRowLike {
+    put(column: string, value: unknown, cb: (err: unknown, result?: unknown) => void): void;
+    put(columns: string[], values: unknown[], cb: (err: unknown, result?: unknown) => void): void;
+    get(cb: (err: unknown, cells?: unknown) => void): void;
+    delete(cb: (err: unknown, result?: unknown) => void): void;
+}
+/**
+ * Minimal structural type for the fluent `table(name)` handle the `hbase`
+ * driver returns.
+ */
+export interface HBaseTableLike {
+    row(key: string): HBaseRowLike;
+    create(schema: unknown, cb: (err: unknown, result?: unknown) => void): void;
+    scan(options: Record<string, unknown>, cb: (err: unknown, rows?: unknown) => void): void;
+}
+/**
+ * Minimal structural type for the pieces of an `hbase` client this store uses.
+ * Kept local (rather than importing from `hbase`) so this module type-checks
+ * without the optional driver installed.
+ */
+export interface HBaseClientLike {
+    table(name: string): HBaseTableLike;
+}
+/** Options accepted by the `scan()` helper; forwarded straight to the driver. */
+export interface HBaseScanOptions {
+    /** Inclusive start row key for the range scan. */
+    startRow?: string;
+    /** Exclusive end row key for the range scan. */
+    endRow?: string;
+    /** Restrict the scan to these `'family'` or `'family:qualifier'` columns. */
+    columns?: string[];
+    /** Maximum number of rows to return. */
+    maxVersions?: number;
+    /** Batch size for the underlying scanner. */
+    batch?: number;
+    [key: string]: unknown;
+}
+/**
+ * Connection options for `HBaseStore`. These map onto the `hbase` client
+ * constructor options (a Stargate / REST gateway host + port).
+ */
+export interface HBaseStoreOptions {
+    /** REST/Stargate gateway host, e.g. '127.0.0.1'. */
+    host?: string;
+    /** REST/Stargate gateway port, e.g. 8080. */
+    port?: number;
+    /**
+     * Escape hatch for any other `hbase` client option (protocol, encoding,
+     * auth, timeout, ...). Merged into the options passed to the client factory.
+     */
+    clientOptions?: Record<string, unknown>;
+    /**
+     * A pre-built `hbase` client (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('hbase')` entirely — this
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: HBaseClientLike;
+}
+/**
+ * `HBaseStore` wraps an `hbase` REST-gateway client and exposes HBase's
+ * row/cell surface: `put`/`get`/`deleteRow` for single-row operations, `scan`
+ * for range reads over the sorted key space, and `createTable` for defining a
+ * table's column families. Column cells are addressed as `'family:qualifier'`.
+ */
+export declare class HBaseStore implements NoSqlStore {
+    readonly name = "hbase";
+    readonly library = "hbase";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: HBaseStoreOptions);
+    connect(): Promise<void>;
+    /**
+     * The `hbase` REST client is stateless (each call is an HTTP request), so
+     * there is no socket to tear down; `disconnect()` simply drops the reference
+     * and flips `connected` to false.
+     */
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `hbase` client for anything not wrapped here. */
+    getClient(): HBaseClientLike;
+    private requireClient;
+    private wrapError;
+    /**
+     * Writes (puts) one or more cells into a single row. `data` maps
+     * `'family:qualifier'` column keys to values, e.g.
+     * `{ 'cf:name': 'alice', 'cf:age': 30 }`. Passed to the driver as parallel
+     * `columns`/`values` arrays via `table(table).row(row).put(...)`.
+     */
+    put(table: string, row: string, data: HBaseRowData): Promise<unknown>;
+    /**
+     * Reads a single row by key via `table(table).row(row).get(...)`, returning
+     * the row's cells as the driver surfaces them (an array of
+     * `{ column, timestamp, $ }` cell descriptors for the `hbase` REST client).
+     */
+    get(table: string, row: string): Promise<unknown>;
+    /** Deletes an entire row (all its cells) via `table(table).row(row).delete(...)`. */
+    deleteRow(table: string, row: string): Promise<unknown>;
+    /**
+     * Range-scans a table via `table(table).scan(options, ...)`, returning the
+     * matching rows. Since HBase keeps row keys sorted, `startRow`/`endRow`
+     * define an efficient contiguous range; `columns` restricts which families/
+     * qualifiers are read. Returns the rows as the driver surfaces them.
+     */
+    scan(table: string, opts?: HBaseScanOptions): Promise<unknown>;
+    /**
+     * Creates a table with the given column families via
+     * `table(table).create(...)`. `families` is the list of column family names
+     * (e.g. `['cf', 'meta']`); each is sent to the driver as an HBase
+     * `ColumnSchema` entry. A table must declare its families up front — unlike
+     * qualifiers, families cannot be added implicitly at write time.
+     */
+    createTable(table: string, families: string[]): Promise<unknown>;
+}
+export default HBaseStore;