ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,78 @@
+/**
+ * Azure Cosmos DB store implementation for the Prorm NoSQL layer.
+ *
+ * Cosmos DB is a multi-model database (document, key/value, graph, column)
+ * exposed here through its document (SQL/Core) API. Documents live in a
+ * container within a database and are addressed by an `id`. It does not fit
+ * the SQL-shaped `Dialect` interface (no identifier escaping, no DDL
+ * builder), so this class implements the minimal `NoSqlStore` marker
+ * interface for connection lifecycle and otherwise exposes Cosmos DB's real
+ * item CRUD plus SQL query API directly.
+ *
+ * Uses the official `@azure/cosmos` SDK. That driver is an optional peer
+ * dependency and is loaded lazily inside `connect()` so importing this module
+ * never requires it to be installed. Tests inject a pre-built mock `client`
+ * via `options.client`, which bypasses the lazy `require` entirely - no real
+ * driver and no network are needed.
+ */
+import { NoSqlStore } from '../store';
+/** A native `CosmosClient` handle, left untyped because the driver is an
+ * optional dependency not imported here. */
+type CosmosClient = any;
+/**
+ * Connection options for `CosmosDbStore`.
+ *
+ * `endpoint`/`key` authenticate against the Cosmos DB account. `database`
+ * selects the default database and `container` the default container that
+ * CRUD methods target when no explicit container is passed. When a pre-built
+ * `client` is supplied (e.g. in tests), `connect()` uses it directly and
+ * skips loading the `@azure/cosmos` driver.
+ */
+export interface CosmosDbStoreOptions {
+    /** Cosmos DB account endpoint, e.g. `https://acct.documents.azure.com`. */
+    endpoint?: string;
+    /** Cosmos DB account primary/secondary key. */
+    key?: string;
+    /** Default database id. */
+    database?: string;
+    /** Default container id used when a method omits the container. */
+    container?: string;
+    /** A pre-built `CosmosClient` to use instead of connecting via the driver. */
+    client?: CosmosClient;
+}
+/** Options accepted by {@link CosmosDbStore.query}. */
+export interface CosmosDbQueryOptions {
+    /** Additional native `FeedOptions` passed straight through to the SDK. */
+    [key: string]: unknown;
+}
+export declare class CosmosDbStore implements NoSqlStore {
+    readonly name = "cosmosdb";
+    readonly library = "@azure/cosmos";
+    private readonly options;
+    private readonly defaultDatabase;
+    private readonly defaultContainer;
+    private client;
+    private connected;
+    constructor(options?: CosmosDbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getClient(): CosmosClient;
+    private requireClient;
+    /** Resolves a container handle via `database(db).container(container)`. */
+    container(container?: string, database?: string): any;
+    /** Create a document; returns its `id`. */
+    insert(collection: string, doc: Record<string, unknown>): Promise<unknown>;
+    /** Read a document by id, returning its stored resource. */
+    get(collection: string, id: string): Promise<unknown>;
+    /** Merge `patch` into the existing document and replace it. */
+    update(collection: string, id: string, patch: Record<string, unknown>): Promise<unknown>;
+    /** Delete a document by id. */
+    delete(collection: string, id: string): Promise<unknown>;
+    /**
+     * Run a Cosmos SQL query (string or `SqlQuerySpec`) against `collection`
+     * and return the matched resources.
+     */
+    query(collection: string, statement: unknown, options?: CosmosDbQueryOptions): Promise<unknown[]>;
+}
+export default CosmosDbStore;

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

@@ -0,0 +1,103 @@
+/**
+ * Couchbase store implementation for the Prorm NoSQL layer.
+ *
+ * Couchbase is a distributed document/key-value store. Documents live in a
+ * bucket, are addressed by an opaque key within a scope/collection, and can
+ * additionally be queried with N1QL (SQL++). It does not fit the SQL-shaped
+ * `Dialect` interface (no identifier escaping, no DDL builder), so this class
+ * implements the minimal `NoSqlStore` marker interface for connection
+ * lifecycle and otherwise exposes Couchbase's real key/value CRUD plus N1QL
+ * query API directly rather than forcing everything through `query(sql)`.
+ *
+ * Uses the official `couchbase` Node.js SDK. That driver is an optional
+ * peer dependency and is loaded lazily inside `connect()` so importing this
+ * module never requires it to be installed. Tests inject a pre-built mock
+ * `cluster` via `options.cluster`, which bypasses the lazy `require`
+ * entirely - no real driver and no network are needed.
+ */
+import { NoSqlStore } from '../store';
+/** A Couchbase collection handle (the SDK's `Collection`), left untyped
+ * because the driver is an optional dependency not imported here. */
+type CouchbaseCollection = any;
+/** A Couchbase cluster handle (the SDK's `Cluster`). */
+type CouchbaseCluster = any;
+/**
+ * Connection options for `CouchbaseStore`.
+ *
+ * `connectionString` is the standard `couchbase://` / `couchbases://`
+ * endpoint; `username`/`password` authenticate against the cluster. The
+ * default `bucket`/`scope`/`collection` select which collection the key/value
+ * CRUD methods operate on when no explicit target is passed. When a pre-built
+ * `cluster` is supplied (e.g. in tests), `connect()` uses it directly and
+ * skips loading the `couchbase` driver.
+ */
+export interface CouchbaseStoreOptions {
+    /** Couchbase connection string, e.g. `couchbase://localhost`. */
+    connectionString?: string;
+    /** Username for cluster authentication. */
+    username?: string;
+    /** Password for cluster authentication. */
+    password?: string;
+    /** Default bucket for key/value operations (default: `default`). */
+    bucket?: string;
+    /** Default scope within the bucket (default: `_default`). */
+    scope?: string;
+    /** Default collection within the scope (default: `_default`). */
+    collection?: string;
+    /** A pre-built cluster to use instead of connecting via the driver. */
+    cluster?: CouchbaseCluster;
+}
+/** Options accepted by {@link CouchbaseStore.query}. */
+export interface CouchbaseQueryOptions {
+    /** Positional or named parameters bound into the N1QL statement. */
+    parameters?: unknown[] | Record<string, unknown>;
+    /** Any additional native query options passed straight through. */
+    [key: string]: unknown;
+}
+/**
+ * `CouchbaseStore` wraps the official `couchbase` SDK's
+ * `Cluster`/`Bucket`/`Collection` API in a small key/value CRUD plus N1QL
+ * convenience layer.
+ */
+export declare class CouchbaseStore implements NoSqlStore {
+    readonly name = "couchbase";
+    readonly library = "couchbase";
+    private readonly options;
+    private readonly defaultBucket;
+    private readonly defaultScope;
+    private readonly defaultCollection;
+    private cluster;
+    private connected;
+    constructor(options?: CouchbaseStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying native `Cluster` for anything not wrapped here. */
+    getClient(): CouchbaseCluster;
+    private requireCluster;
+    /**
+     * Resolves a collection handle. With no arguments (or only a bucket) it
+     * uses the store's configured defaults; passing an explicit
+     * `scope`/`collection` targets a non-default collection via
+     * `bucket.scope(scope).collection(collection)`, otherwise it falls back to
+     * `bucket.defaultCollection()`.
+     */
+    collection(bucket?: string, scope?: string, collection?: string): CouchbaseCollection;
+    /** Insert a new document; fails if the key already exists. */
+    insert(id: string, doc: unknown): Promise<unknown>;
+    /** Insert or replace a document by key. */
+    upsert(id: string, doc: unknown): Promise<unknown>;
+    /** Fetch a document by key, returning its `.content` (the stored value). */
+    get(id: string): Promise<unknown>;
+    /** Replace an existing document; fails if the key does not exist. */
+    replace(id: string, doc: unknown): Promise<unknown>;
+    /** Remove a document by key. */
+    remove(id: string): Promise<unknown>;
+    /**
+     * Run a N1QL/SQL++ `statement` against the cluster and return its result
+     * rows. `options.parameters` binds positional (array) or named (object)
+     * parameters into the statement.
+     */
+    query(statement: string, options?: CouchbaseQueryOptions): Promise<unknown[]>;
+}
+export default CouchbaseStore;

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

@@ -0,0 +1,118 @@
+/**
+ * DAX (Amazon DynamoDB Accelerator) store implementation.
+ *
+ * DAX is a fully managed, in-memory, write-through cache for Amazon
+ * DynamoDB. It is not a standalone database - it is a DynamoDB *cache* that
+ * speaks the DynamoDB wire API, so the `amazon-dax-client` driver is a
+ * drop-in replacement for the low-level `AWS.DynamoDB` client
+ * (`getItem`/`putItem`/`deleteItem`/`scan`, each returning a request with a
+ * `.promise()`).
+ *
+ * This class implements the minimal `NoSqlStore` marker interface and maps a
+ * simple edge-KV surface onto a single DynamoDB table used as a key-value
+ * bucket:
+ *
+ * - `get(key)`    -> `getItem`   (Key = { <keyAttr>: key })
+ * - `set(k,v)`    -> `putItem`   (Item = { <keyAttr>: key, <valueAttr>: value })
+ * - `del(key)`    -> `deleteItem`
+ * - `list(pref?)` -> `scan`      (returns the `<keyAttr>` of each item)
+ * - `incr(k,by?)` -> read-modify-write over `getItem`/`putItem`
+ *   (non-atomic; documented).
+ *
+ * ## Driver
+ *
+ * Uses `amazon-dax-client`. The driver is loaded lazily inside `connect()`
+ * (or supplied pre-built via the `client` option) so importing this module
+ * never requires `amazon-dax-client` to be installed unless a store is
+ * actually connected. Tests inject a mock `client`.
+ *
+ * ## Serialization
+ *
+ * Values are stored as DynamoDB string (`S`) attributes: strings verbatim,
+ * every other value `JSON.stringify`'d first.
+ */
+import { NoSqlStore } from '../store';
+/** An AWS SDK v2-style request wrapper. */
+export interface DaxRequest<T> {
+    promise(): Promise<T>;
+}
+/** The subset of the DynamoDB/DAX low-level client surface this store drives. */
+export interface DaxClient {
+    getItem(params: Record<string, any>): DaxRequest<{
+        Item?: Record<string, any>;
+    }>;
+    putItem(params: Record<string, any>): DaxRequest<any>;
+    deleteItem(params: Record<string, any>): DaxRequest<any>;
+    scan(params: Record<string, any>): DaxRequest<{
+        Items?: Record<string, any>[];
+    }>;
+}
+/** Options for `set()`. */
+export interface DaxSetOptions {
+    /**
+     * Expire after this many seconds. Written as a DynamoDB TTL attribute
+     * (`ttlAttr`) holding the absolute Unix-seconds expiry. Requires TTL to be
+     * enabled on the table with a matching attribute name.
+     */
+    ttl?: number;
+    /** Absolute expiration as a Unix timestamp in seconds (written to `ttlAttr`). */
+    expiration?: number;
+}
+/** Connection options for `DaxStore`. */
+export interface DaxStoreOptions {
+    /** DynamoDB table used as the KV bucket (required). */
+    tableName?: string;
+    /** Partition-key attribute name holding the key. Defaults to `'key'`. */
+    keyAttr?: string;
+    /** Attribute name holding the value. Defaults to `'value'`. */
+    valueAttr?: string;
+    /** TTL attribute name used by `set()` options. Defaults to `'ttl'`. */
+    ttlAttr?: string;
+    /** DAX cluster endpoints (e.g. `['dax://my-cluster.abc.dax-clusters.us-east-1.amazonaws.com']`). */
+    endpoints?: string[];
+    /** AWS region. */
+    region?: string;
+    /** Pre-built DAX client; when given `connect()` uses it and skips `require('amazon-dax-client')`. */
+    client?: DaxClient;
+}
+/**
+ * `DaxStore` wraps an `amazon-dax-client` (DynamoDB-compatible) client behind
+ * the `NoSqlStore` lifecycle and an edge-KV `get`/`set`/`del`/`list`/`incr`
+ * surface over a single DynamoDB table.
+ */
+export declare class DaxStore implements NoSqlStore {
+    readonly name = "dax";
+    readonly library = "amazon-dax-client";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: DaxStoreOptions);
+    private get tableName();
+    private get keyAttr();
+    private get valueAttr();
+    private get ttlAttr();
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying DAX (DynamoDB-compatible) client for anything not wrapped here. */
+    getClient(): DaxClient;
+    private requireClient;
+    /** Read a key via `getItem`. Returns the stored string, or `null` if missing. */
+    get(key: string): Promise<string | null>;
+    /**
+     * Write `value` under `key` via `putItem`. Strings are stored verbatim;
+     * other values are JSON-serialized. `options.ttl`/`options.expiration`
+     * populate the table's TTL attribute (`ttlAttr`).
+     */
+    set(key: string, value: unknown, options?: DaxSetOptions): Promise<void>;
+    /** Delete a key via `deleteItem`. */
+    del(key: string): Promise<void>;
+    /** List key names via `scan`, optionally filtered to those beginning with `prefix`. */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Increment the numeric value at `key` by `by` (default `1`). Implemented
+     * as a non-atomic read-modify-write over `getItem`/`putItem`.
+     */
+    incr(key: string, by?: number): Promise<number>;
+}
+export default DaxStore;

package/dist/nosql/deno-kv/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Deno KV store implementation.
+ *
+ * Deno KV is a globally-distributed, serverless key-value database. Outside
+ * a Deno runtime it is reached over the network with the KV Connect
+ * protocol, which is an HTTP/JSON transport. This class implements the
+ * minimal `NoSqlStore` marker interface and exposes an edge-KV
+ * `get`/`set`/`del`/`list`/`incr` surface.
+ *
+ * ## No canonical Node driver - HTTP over `fetch` (KV Connect assumption)
+ *
+ * There is no first-party Node client for Deno KV, so `library` is
+ * `'fetch'`. This store assumes a **KV Connect-style HTTP gateway** that
+ * exposes a small REST surface for the underlying database:
+ *
+ * - `get(key)`    -> `GET    /kv/values/<key>`  (404 => `null`)
+ * - `set(k,v)`    -> `PUT    /kv/values/<key>`  (body + optional `expireIn`)
+ * - `del(key)`    -> `DELETE /kv/values/<key>`
+ * - `list(pref?)` -> `GET    /kv/keys?prefix=`  (returns the key names)
+ * - `incr(k,by?)` -> read-modify-write over `get`/`set` (documented as
+ *   non-atomic; the native `atomic().sum()` op is not modeled here).
+ *
+ * Keys are treated as opaque strings (Deno KV's array key parts are joined
+ * by the caller). For tests (and callers with their own transport) an
+ * alternative HTTP client can be injected via `client`; when omitted a tiny
+ * internal `fetch`-based client is built at `connect()` time.
+ *
+ * ## Serialization
+ *
+ * String values are stored verbatim; every other value is `JSON.stringify`'d
+ * before being written.
+ */
+import { NoSqlStore } from '../store';
+/** A minimal `fetch`-`Response`-like shape used by the HTTP client. */
+export interface FetchLikeResponse {
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+    json(): Promise<any>;
+}
+/** Request init recognized by the HTTP client. */
+export interface HttpRequestInit {
+    body?: string;
+    /** Query-string params; `undefined` values are dropped. */
+    query?: Record<string, string | undefined>;
+}
+/**
+ * The subset of an HTTP client this store needs. The internal `fetch`-based
+ * client implements this; tests inject a mock of the same shape that records
+ * every request.
+ */
+export interface DenoKvHttpClient {
+    request(method: string, path: string, init?: HttpRequestInit): Promise<FetchLikeResponse>;
+}
+/** Options for `set()`. */
+export interface DenoKvSetOptions {
+    /** Expire after this many milliseconds (Deno KV `expireIn`). */
+    ttl?: number;
+    /** Absolute expiration as a Unix timestamp (ms); sent as `expireAt`. */
+    expiration?: number;
+}
+/** Connection options for `DenoKvStore`. */
+export interface DenoKvStoreOptions {
+    /** Base URL of the KV Connect HTTP gateway. */
+    url?: string;
+    /** Access token used as a `Bearer` credential. */
+    accessToken?: string;
+    /** Pre-built HTTP client; when given `connect()` uses it verbatim. */
+    client?: DenoKvHttpClient;
+}
+/** Build a `fetch`-backed HTTP client for the KV Connect gateway. */
+export declare function createFetchClient(baseURL: string, accessToken?: string): DenoKvHttpClient;
+/**
+ * `DenoKvStore` wraps a KV Connect HTTP gateway behind the `NoSqlStore`
+ * lifecycle and an edge-KV `get`/`set`/`del`/`list`/`incr` surface.
+ */
+export declare class DenoKvStore implements NoSqlStore {
+    readonly name = "deno-kv";
+    readonly library = "fetch";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: DenoKvStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): DenoKvHttpClient;
+    private requireClient;
+    private valuePath;
+    /** Read a key. Returns `null` on a 404 (missing key). */
+    get(key: string): Promise<string | null>;
+    /**
+     * Write `value` under `key`. Strings are stored verbatim; other values are
+     * JSON-serialized. `options.ttl` maps to `expireIn` (ms), `options.expiration`
+     * to `expireAt` (absolute Unix ms).
+     */
+    set(key: string, value: unknown, options?: DenoKvSetOptions): Promise<void>;
+    /** Delete a key. */
+    del(key: string): Promise<void>;
+    /** List key names, optionally filtered by `prefix`. */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Increment the numeric value at `key` by `by` (default `1`). Implemented
+     * as a non-atomic read-modify-write over `get`/`set`.
+     */
+    incr(key: string, by?: number): Promise<number>;
+}
+export default DenoKvStore;

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

@@ -0,0 +1,80 @@
+import type { NoSqlStore } from '../store';
+/** A DQL transaction handle, as returned by `client.newTxn()`. */
+export interface DgraphTxnLike {
+    queryWithVars(query: string, vars?: Record<string, string>): Promise<{
+        getJson(): string;
+    }>;
+    mutate(mutation: Record<string, unknown>): Promise<unknown>;
+    discard(): Promise<void>;
+}
+/**
+ * Minimal structural type for the pieces of a `dgraph-js` `DgraphClient` this
+ * store uses. Kept local (rather than importing from `dgraph-js`) so this
+ * module type-checks without the optional driver installed.
+ */
+export interface DgraphClientLike {
+    newTxn(): DgraphTxnLike;
+    alter(operation: Record<string, unknown>): Promise<unknown>;
+}
+/** A closable `dgraph-js` client stub (`DgraphClientStub`). */
+export interface DgraphStubLike {
+    close(): void;
+}
+/** Connection options for `DgraphStore`. */
+export interface DgraphStoreOptions {
+    /** Dgraph Alpha gRPC address, e.g. `'localhost:9080'`. */
+    address?: string;
+    /**
+     * A pre-built `dgraph-js` `DgraphClient` (or a compatible mock). When
+     * provided, `connect()` uses it directly and skips `require('dgraph-js')`
+     * entirely — this is how tests inject a mock without the real driver
+     * installed.
+     */
+    client?: DgraphClientLike;
+}
+/**
+ * `DgraphStore` wraps a `dgraph-js` `DgraphClient` and exposes Dgraph's real
+ * surface: `query()` for parameterized DQL reads, `mutate()` for JSON
+ * mutations (auto-committed), and `alter()`/`dropAll()` for schema/data
+ * management.
+ */
+export declare class DgraphStore implements NoSqlStore {
+    readonly name = "dgraph";
+    readonly library = "dgraph-js";
+    private readonly options;
+    private client;
+    /** The client stub, kept so `disconnect()` can close its gRPC channel. Null when a client is injected. */
+    private stub;
+    private connected;
+    constructor(options?: DgraphStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `dgraph-js` `DgraphClient` for anything not wrapped here. */
+    getClient(): DgraphClientLike;
+    private requireClient;
+    private wrapError;
+    /**
+     * Runs a parameterized DQL query in a fresh transaction and returns the
+     * parsed JSON result. `vars` binds DQL query variables (e.g.
+     * `{ $name: 'alice' }`) sent separately from the query text. The
+     * transaction is always discarded in a `finally` — a read-only query never
+     * needs committing, and discarding releases its server-side resources.
+     */
+    query<T = Record<string, unknown>>(dql: string, vars?: Record<string, string>): Promise<T>;
+    /**
+     * Applies a JSON mutation (`setJson`) and commits it immediately
+     * (`commitNow: true`), so no separate commit round trip is needed. The
+     * transaction is discarded in a `finally` as a safety net (committed
+     * transactions treat discard as a no-op).
+     */
+    mutate(setJson: Record<string, unknown> | unknown[]): Promise<unknown>;
+    /**
+     * Alters the schema by forwarding a DQL schema definition (DDL) to
+     * `client.alter({ schema })`, e.g. `'name: string @index(exact) .'`.
+     */
+    alter(schema: string): Promise<unknown>;
+    /** Drops all data and schema in the cluster via `client.alter({ dropAll: true })`. */
+    dropAll(): Promise<unknown>;
+}
+export default DgraphStore;

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

@@ -0,0 +1,88 @@
+/**
+ * Apache Doris store.
+ *
+ * Apache Doris is a real-time MPP analytical (OLAP) database. Like StarRocks
+ * (with which it shares ancestry), it speaks the **MySQL wire protocol**, so
+ * it is queried with the `mysql2` driver over a normal MySQL connection/pool.
+ * Doris is a columnar analytics engine rather than an OLTP store, which does
+ * not fit this ORM's SQL `Dialect` abstraction cleanly, so it is modelled as
+ * a `NoSqlStore` (`src/nosql/store.ts`) exposing a direct `query`/`ingest`
+ * surface.
+ *
+ * ## Driver: `mysql2` (MySQL-wire)
+ *
+ * The `mysql2` package is an optional peer dependency, lazily `require`d
+ * inside `connect()` so importing this module never forces it to be
+ * installed. Tests inject a pre-built mock connection via
+ * `DorisStoreOptions.client`, which skips the `require` entirely.
+ *
+ * ## Ingestion
+ *
+ * `ingest()` performs a batched `INSERT` over the MySQL wire. For
+ * high-throughput loading Doris also offers **Stream Load** (an HTTP
+ * `PUT /api/{db}/{table}/_stream_load` endpoint). Stream Load is a separate
+ * (optional) HTTP transport and is intentionally not wired here; use the
+ * `mysql2`-based `ingest()` for wire-level inserts, or POST to the Stream Load
+ * endpoint yourself for bulk pipelines.
+ */
+import type { NoSqlStore } from '../store';
+/**
+ * Minimal structural type for the pieces of a `mysql2/promise` connection (or
+ * pool) this store uses. Kept local so this module type-checks without the
+ * optional driver installed. `query()` resolves to `[rows, fields]`.
+ */
+export interface MysqlConnectionLike {
+    query(sql: string, params?: unknown[]): Promise<[any, any]>;
+    end?(): Promise<void>;
+}
+/** Connection options for `DorisStore` (map onto `mysql2` connection config). */
+export interface DorisStoreOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    /** Escape hatch for any other `mysql2` connection option. */
+    connectionOptions?: Record<string, unknown>;
+    /**
+     * A pre-built `mysql2` connection/pool (or compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('mysql2/promise')`. This
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: MysqlConnectionLike;
+}
+/**
+ * `DorisStore` wraps a `mysql2` connection to a Doris frontend and exposes
+ * `query(sql, params)` for reads/DDL and `ingest(table, rows)` for batched
+ * wire-level inserts.
+ */
+export declare class DorisStore implements NoSqlStore {
+    readonly name = "doris";
+    readonly library = "mysql2";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: DorisStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `mysql2` connection for anything not wrapped here. */
+    getClient(): MysqlConnectionLike;
+    private requireClient;
+    /**
+     * Execute a SQL statement over the MySQL wire with optional positional
+     * `params` and return the result rows (the first element of `mysql2`'s
+     * `[rows, fields]` tuple).
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Batch-insert `rows` into `table` via a single parameterized
+     * `INSERT INTO table (cols) VALUES (...)` over the MySQL wire. Columns are
+     * taken from the first row. Returns the driver result (`OkPacket`).
+     *
+     * For high-throughput bulk loading, use Doris Stream Load (HTTP) instead —
+     * see the module header.
+     */
+    ingest(table: string, rows: Array<Record<string, unknown>>): Promise<any>;
+}
+export default DorisStore;

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

@@ -0,0 +1,95 @@
+/**
+ * Apache Druid store.
+ *
+ * Druid is a real-time OLAP / analytics datastore designed for sub-second
+ * queries over large event streams. It is not a relational database: it has
+ * no cross-datasource joins in the classic sense, no row-level UPDATE/DELETE,
+ * and ingestion happens by submitting *tasks* to an indexing service rather
+ * than by running `INSERT`. That model does not fit the SQL-shaped `Dialect`
+ * interface (`src/dialects/dialect.ts`), so this class implements the minimal
+ * `NoSqlStore` marker interface (`src/nosql/store.ts`) and talks to Druid's
+ * HTTP JSON API directly.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Druid has no single canonical npm client; it is just an HTTP/JSON API.
+ * Rather than depend on any package this store uses the global `fetch`. Tests
+ * (and callers wanting their own transport) can inject an alternative client
+ * via `DruidStoreOptions.client`; when omitted a tiny `fetch`-based client is
+ * built against `endpoint` at `connect()` time.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `query(sql, params?)`  -> `POST /druid/v2/sql`      (Druid SQL, returns rows)
+ * - `nativeQuery(spec)`    -> `POST /druid/v2`          (native JSON query)
+ * - `ingest(target, rows)` -> `POST /druid/indexer/v1/task` (inline index task)
+ * - `submitTask(spec)`     -> `POST /druid/indexer/v1/task` (arbitrary task spec)
+ */
+import { NoSqlStore } from '../store';
+/** Default Druid router/broker HTTP endpoint. */
+export declare const DEFAULT_DRUID_ENDPOINT = "http://localhost:8888";
+/**
+ * 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 DruidHttpClient {
+    /** Issue a POST with a JSON body and return the parsed JSON response. */
+    post(path: string, body: unknown): Promise<any>;
+}
+/** Connection options for `DruidStore`. */
+export interface DruidStoreOptions {
+    /** Base HTTP endpoint of the Druid router/broker. Defaults to `http://localhost:8888`. */
+    endpoint?: string;
+    /**
+     * Optional pre-built HTTP client. When provided it is used verbatim and
+     * `endpoint` is ignored; otherwise an internal `fetch`-based client is built
+     * against `endpoint` on `connect()`. Tests inject a mock here.
+     */
+    client?: DruidHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Build a `fetch`-backed client for the given endpoint. */
+export declare function createFetchClient(endpoint: string, headers?: Record<string, string>): DruidHttpClient;
+/**
+ * `DruidStore` wraps Druid's HTTP query + indexing API behind the
+ * `NoSqlStore` lifecycle: SQL and native queries for reads, task submission
+ * for ingestion.
+ */
+export declare class DruidStore implements NoSqlStore {
+    readonly name = "druid";
+    readonly library = "fetch";
+    private readonly endpoint;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: DruidStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): DruidHttpClient;
+    private requireClient;
+    private post;
+    /**
+     * Run a Druid SQL query via `POST /druid/v2/sql`. Optional positional
+     * `params` are sent as Druid SQL parameters (`{ value }` objects). Druid
+     * returns an array of row objects, which is returned as-is.
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Run a native (JSON) Druid query via `POST /druid/v2`. Returns the parsed
+     * response body (shape depends on the native query type).
+     */
+    nativeQuery<T = unknown>(spec: Record<string, unknown>): Promise<T>;
+    /**
+     * Ingest `rows` into datasource `target` by submitting an inline
+     * `index_parallel` task to `POST /druid/indexer/v1/task`. Returns the task
+     * submission response (typically `{ task: '<id>' }`).
+     */
+    ingest(target: string, rows: Array<Record<string, unknown>>): Promise<any>;
+    /** Submit an arbitrary task spec to `POST /druid/indexer/v1/task`. */
+    submitTask(spec: Record<string, unknown>): Promise<any>;
+}
+export default DruidStore;