ts-prorm-orm 1.1.0 → 1.2.0

package/dist/nosql/neo4j/index.js

@@ -14,13 +14,25 @@
  *
  * Uses the official `neo4j-driver` (Bolt protocol) driver.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Neo4jStore = void 0;
 exports.intToNumber = intToNumber;
-const neo4j_driver_1 = __importDefault(require("neo4j-driver"));
+// Lazily-loaded `neo4j-driver`. Required only when a connection is opened, so
+// importing this ORM never loads the neo4j driver.
+let neo4jModule = null;
+function loadNeo4j() {
+    if (!neo4jModule) {
+        try {
+            neo4jModule = require('neo4j-driver');
+        }
+        catch (err) {
+            throw new Error("The 'neo4j-driver' package is required to use the Neo4j store but could not be loaded. " +
+                'Install it with `npm install neo4j-driver`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return neo4jModule;
+}
 const errors_1 = require("../../errors");
 function wrapConnectionError(err, host) {
     const parent = err instanceof Error ? err : new Error(String(err));
@@ -60,10 +72,10 @@ function mapValue(value) {
     if (value === null || value === undefined) {
         return value;
     }
-    if (neo4j_driver_1.default.isInt(value)) {
+    if (loadNeo4j().isInt(value)) {
         return intToNumber(value);
     }
-    if (neo4j_driver_1.default.isNode(value)) {
+    if (loadNeo4j().isNode(value)) {
         const node = value;
         const mapped = {
             elementId: node.elementId,
@@ -73,7 +85,7 @@ function mapValue(value) {
         };
         return mapped;
     }
-    if (neo4j_driver_1.default.isRelationship(value)) {
+    if (loadNeo4j().isRelationship(value)) {
         const rel = value;
         const mapped = {
             elementId: rel.elementId,
@@ -158,7 +170,7 @@ class Neo4jStore {
             return this.options.auth;
         }
         if (this.options.username !== undefined || this.options.password !== undefined) {
-            return neo4j_driver_1.default.auth.basic(this.options.username ?? '', this.options.password ?? '');
+            return loadNeo4j().auth.basic(this.options.username ?? '', this.options.password ?? '');
         }
         return undefined;
     }
@@ -168,7 +180,7 @@ class Neo4jStore {
         }
         let candidate = null;
         try {
-            candidate = neo4j_driver_1.default.driver(this.options.uri, this.resolveAuth(), this.options.config);
+            candidate = loadNeo4j().driver(this.options.uri, this.resolveAuth(), this.options.config);
             await candidate.verifyConnectivity(this.options.database ? { database: this.options.database } : undefined);
             this.driverInstance = candidate;
             this.connected = true;
@@ -218,7 +230,7 @@ class Neo4jStore {
         const driver = this.requireDriver();
         return driver.session({
             database: options.database ?? this.options.database,
-            defaultAccessMode: options.defaultAccessMode === 'READ' ? neo4j_driver_1.default.session.READ : neo4j_driver_1.default.session.WRITE,
+            defaultAccessMode: options.defaultAccessMode === 'READ' ? loadNeo4j().session.READ : loadNeo4j().session.WRITE,
         });
     }
     // ---------------------------------------------------------------------
@@ -360,11 +372,11 @@ class Neo4jStore {
         const params = { ...where };
         if (options.skip !== undefined) {
             cypher += ' SKIP $skip';
-            params.skip = neo4j_driver_1.default.int(options.skip);
+            params.skip = loadNeo4j().int(options.skip);
         }
         if (options.limit !== undefined) {
             cypher += ' LIMIT $limit';
-            params.limit = neo4j_driver_1.default.int(options.limit);
+            params.limit = loadNeo4j().int(options.limit);
         }
         const result = await this.run(cypher, params);
         return result.records.map((record) => record.n);
@@ -430,11 +442,11 @@ class Neo4jStore {
         const params = { ...where };
         if (options.skip !== undefined) {
             cypher += ' SKIP $skip';
-            params.skip = neo4j_driver_1.default.int(options.skip);
+            params.skip = loadNeo4j().int(options.skip);
         }
         if (options.limit !== undefined) {
             cypher += ' LIMIT $limit';
-            params.limit = neo4j_driver_1.default.int(options.limit);
+            params.limit = loadNeo4j().int(options.limit);
         }
         const result = await this.run(cypher, params);
         return result.records.map((record) => record.r);

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

@@ -0,0 +1,234 @@
+/**
+ * Amazon Neptune store.
+ *
+ * Neptune is a managed graph database: data is modeled as vertices and
+ * edges (plus their properties), queried by graph traversal, not by
+ * arbitrary `WHERE`-clause SQL. It has no joins, no relational schema, and
+ * no `query(sql)` shape, so — like the other stores in `src/nosql/` — this
+ * class does not implement the SQL-shaped `Dialect` interface
+ * (`src/dialects/dialect.ts`). Instead it implements the minimal
+ * `NoSqlStore` marker interface (`src/nosql/store.ts`) and exposes
+ * Neptune's own query model directly: Gremlin traversals.
+ *
+ * Neptune supports two graph query languages: Gremlin and openCypher.
+ * This store uses **Gremlin**, via the official `gremlin` npm package
+ * (Apache TinkerPop's JavaScript Gremlin Language Variant), because it is
+ * the more universally-supported path for Neptune from Node.js — the
+ * `gremlin` package speaks Neptune's Gremlin websocket protocol directly
+ * (`DriverRemoteConnection` for the fluent, bytecode-based traversal API;
+ * `Client` for raw Gremlin script submission).
+ *
+ * ## IAM authentication — read this before using in production
+ *
+ * Neptune clusters can require AWS IAM (SigV4) request signing on every
+ * Gremlin connection. **This store does NOT implement SigV4 signing.**
+ * Correctly signing a websocket handshake (canonical request, credential
+ * scope, signing key derivation, clock-skew-sensitive timestamps, and
+ * keeping all of that valid for the life of a persistent connection) is
+ * substantial, security-sensitive logic that is easy to get subtly wrong,
+ * and shipping a partial/approximate implementation would be worse than
+ * not shipping one — silent auth failures or, worse, requests that
+ * "happen to work" against a lenient test setup but fail against real
+ * Neptune are not an acceptable trade-off here.
+ *
+ * Instead, `NeptuneStoreOptions` supports two supported ways to connect:
+ *
+ * 1. **No auth** — Neptune clusters are frequently run inside a VPC with
+ *    IAM database authentication *disabled*, relying on VPC/security-group
+ *    isolation instead. Just supply `endpoint`/`url` and nothing else.
+ * 2. **Caller-supplied signed headers** — if the target cluster has IAM
+ *    auth enabled, sign the request yourself (e.g. with
+ *    `@aws-sdk/signature-v4` / `aws4`, or your own SigV4 helper) and pass
+ *    the resulting headers via `options.headers` (static) or
+ *    `options.authHeaderProvider` (called on every `connect()`, so it can
+ *    mint a fresh signature — SigV4 signatures are timestamp-bound and a
+ *    static one will eventually be rejected). This store passes those
+ *    headers straight through to `DriverRemoteConnection`/`Client` via
+ *    their `options.headers` field; it performs no signing of its own.
+ *
+ * See the README in this directory for a worked example of option 2.
+ */
+import { DatabaseError } from '../../errors';
+import type { NoSqlStore } from '../store';
+/** Anything Gremlin/Neptune accepts as an element ID: string, number, or a custom ID object. */
+export type NeptuneId = string | number | Record<string, unknown>;
+/** A vertex or edge normalized from Gremlin's `Map`/`Vertex`/`Edge` result shapes into a plain object. */
+export interface NeptuneVertex<P extends Record<string, unknown> = Record<string, unknown>> {
+    id: NeptuneId;
+    label: string;
+    properties: P;
+}
+/** A normalized edge; `outV`/`inV` are the endpoint vertex IDs (the edge's tail/head). */
+export interface NeptuneEdge<P extends Record<string, unknown> = Record<string, unknown>> {
+    id: NeptuneId;
+    label: string;
+    outV: NeptuneId;
+    inV: NeptuneId;
+    properties: P;
+}
+/** Filters shared by `findVertices()`/`findEdges()`. */
+export interface ElementQueryOptions {
+    /** Restrict to a single label, i.e. a `hasLabel(label)` step. */
+    label?: string;
+    /**
+     * Equality filters, one `has(key, value)` step per entry. All entries
+     * are ANDed together (Gremlin's default `has()` chaining behavior).
+     * For anything beyond flat equality (ranges, `P.within`, regex, OR
+     * logic), use `traversal()` directly.
+     */
+    has?: Record<string, unknown>;
+    /** Caps the number of results, i.e. a `limit(n)` step. */
+    limit?: number;
+}
+/** Direction to traverse for `neighbors()`. */
+export type NeptuneDirection = 'out' | 'in' | 'both';
+/** Options for `neighbors()`. */
+export interface NeighborOptions {
+    /** Defaults to `'out'`. */
+    direction?: NeptuneDirection;
+    /** Restrict to a single edge label. */
+    edgeLabel?: string;
+    limit?: number;
+}
+/**
+ * Supplies pre-signed IAM auth headers (e.g. `Authorization`,
+ * `X-Amz-Date`, `X-Amz-Security-Token`) computed by the caller, called
+ * fresh on every `connect()` since SigV4 signatures are timestamp-bound.
+ * See the "IAM authentication" section above — this store does not sign
+ * requests itself.
+ */
+export type NeptuneAuthHeaderProvider = () => Record<string, string> | Promise<Record<string, string>>;
+export interface NeptuneStoreOptions {
+    /**
+     * Neptune cluster/instance endpoint hostname, e.g.
+     * `'my-cluster.cluster-xxxxxxxxxxxx.us-east-1.neptune.amazonaws.com'`.
+     * Combined with `port` (default `8182`) and `useSsl` (default `true`)
+     * into a `wss://host:port/gremlin` URL. Ignored if `url` is set.
+     */
+    endpoint?: string;
+    /** Port for `endpoint`. Defaults to `8182` (Neptune's default Gremlin websocket port). */
+    port?: number;
+    /**
+     * Full connection URL, e.g. `'wss://my-endpoint:8182/gremlin'`. Takes
+     * precedence over `endpoint`/`port`/`useSsl` when set — use this for
+     * non-standard paths/ports or when connecting through a proxy/tunnel.
+     */
+    url?: string;
+    /** Whether to use `wss://` (true, default) or plain `ws://` (local testing only — Neptune itself requires TLS). */
+    useSsl?: boolean;
+    /** Gremlin traversal source name on the server. Defaults to `'g'`. */
+    traversalSource?: string;
+    /** Verify the server's TLS certificate. Defaults to `true`; only disable for local/self-signed test setups. */
+    rejectUnauthorized?: boolean;
+    /**
+     * Static pre-signed IAM auth headers, merged with (and overridden by)
+     * `authHeaderProvider`'s result if both are given. Omit entirely when
+     * connecting to a cluster with IAM auth disabled. See the "IAM
+     * authentication" section above.
+     */
+    headers?: Record<string, string>;
+    /** Called on every `connect()` to obtain fresh pre-signed IAM auth headers. See the "IAM authentication" section above. */
+    authHeaderProvider?: NeptuneAuthHeaderProvider;
+    /**
+     * Passed straight through to the underlying `DriverRemoteConnection`/
+     * `Client` constructors for anything not covered above (`ca`, `cert`,
+     * `pfx`, `mimeType`, `agent`, `enableCompression`, ...).
+     */
+    connectionOptions?: Record<string, unknown>;
+}
+/** `DatabaseError` subclass used for all Neptune/Gremlin failures wrapped by this store. */
+export declare class NeptuneError extends DatabaseError {
+    constructor(message: string, options?: {
+        code?: import('../../errors').ErrorCode;
+        parent?: Error;
+        original?: string;
+    });
+}
+/**
+ * `NeptuneStore` wraps the `gremlin` package's `DriverRemoteConnection`
+ * (fluent, bytecode-based traversals via a `GraphTraversalSource`, i.e.
+ * `g`) and `Client` (raw Gremlin script submission) to talk to Amazon
+ * Neptune, implementing the minimal `NoSqlStore` marker interface. Vertex/
+ * edge CRUD helpers below are convenience wrappers built on top of real
+ * Gremlin steps (`addV`/`addE`/`has`/`hasLabel`/`drop`/...) — for anything
+ * they don't cover, use `getClient()` (the raw `GraphTraversalSource`),
+ * `traversal()` (build an arbitrary traversal against `g`), or `submit()`
+ * (raw parameterized Gremlin script text).
+ */
+export declare class NeptuneStore implements NoSqlStore {
+    readonly name = "neptune";
+    readonly library = "gremlin";
+    private readonly options;
+    private connection;
+    private g;
+    private client;
+    private connected;
+    constructor(options?: NeptuneStoreOptions);
+    private resolveUrl;
+    private resolveHeaders;
+    connect(): Promise<void>;
+    private safeCloseAll;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `GraphTraversalSource` (`g`) for building traversals not wrapped below. */
+    getClient(): unknown;
+    /** Access to the raw `DriverRemoteConnection`, e.g. to inspect `isOpen` directly. */
+    getConnection(): unknown;
+    private requireG;
+    private requireClient;
+    /**
+     * Runs an arbitrary traversal built against `g` and Gremlin's anonymous
+     * traversal statics (`gremlin.process.statics`, e.g. `statics.V(id)` for
+     * nested traversals like `.to(statics.V(id))`), returning the fully
+     * materialized, normalized result list. This is the escape hatch for any
+     * Gremlin step this store doesn't wrap in a dedicated helper.
+     *
+     * @example
+     * const names = await store.traversal((g) => g.V().hasLabel('person').values('name'));
+     */
+    traversal<T = unknown>(build: (g: unknown, statics: unknown) => unknown): Promise<T[]>;
+    /**
+     * Submits a raw Gremlin script string via the driver's script-eval
+     * `Client` (as opposed to the fluent bytecode traversal `g` used
+     * elsewhere in this class), with `bindings` substituted server-side for
+     * named parameters in the script (e.g. `'g.V(id)'` with
+     * `{ id: '1' }`) — the standard way to parameterize Gremlin script text
+     * without string-concatenating untrusted values into it.
+     */
+    submit<T = unknown>(script: string, bindings?: Record<string, unknown>): Promise<T[]>;
+    /** `addV(label)` + a `property(key, value)` step per entry in `properties`, returning the created vertex via `elementMap()`. */
+    addVertex<P extends Record<string, unknown> = Record<string, unknown>>(label: string, properties?: Record<string, unknown>): Promise<NeptuneVertex<P>>;
+    /** `g.V(id).elementMap().next()` — returns `undefined` if no vertex with that ID exists. */
+    getVertex<P extends Record<string, unknown> = Record<string, unknown>>(id: NeptuneId): Promise<NeptuneVertex<P> | undefined>;
+    /** `g.V()` filtered by `options.label`/`options.has`/`options.limit`, projected with `elementMap()`. */
+    findVertices<P extends Record<string, unknown> = Record<string, unknown>>(options?: ElementQueryOptions): Promise<NeptuneVertex<P>[]>;
+    /** Same filters as `findVertices()`, terminated with `count()` instead of materializing elements. */
+    countVertices(options?: ElementQueryOptions): Promise<number>;
+    /** `g.V(id)` + a `property(key, value)` step per entry in `properties` (existing properties keep their value unless overwritten here), returning the updated vertex. */
+    updateVertex<P extends Record<string, unknown> = Record<string, unknown>>(id: NeptuneId, properties: Record<string, unknown>): Promise<NeptuneVertex<P> | undefined>;
+    /** `g.V(id).drop().iterate()` — also drops any incident edges (Neptune cascades edge drops when their vertex is dropped). No-op (does not throw) if the vertex doesn't exist. */
+    dropVertex(id: NeptuneId): Promise<void>;
+    /**
+     * `g.V(fromId).addE(label).to(statics.V(toId))` + a `property(key, value)`
+     * step per entry in `properties`, returning the created edge via
+     * `elementMap()`. Throws a `NeptuneError` if `fromId`/`toId` don't
+     * resolve to existing vertices (same as real Gremlin `addE`/`to`).
+     */
+    addEdge<P extends Record<string, unknown> = Record<string, unknown>>(fromId: NeptuneId, label: string, toId: NeptuneId, properties?: Record<string, unknown>): Promise<NeptuneEdge<P>>;
+    /** `g.E(id).elementMap().next()` — returns `undefined` if no edge with that ID exists. */
+    getEdge<P extends Record<string, unknown> = Record<string, unknown>>(id: NeptuneId): Promise<NeptuneEdge<P> | undefined>;
+    /** `g.E()` filtered by `options.label`/`options.has`/`options.limit`, projected with `elementMap()`. */
+    findEdges<P extends Record<string, unknown> = Record<string, unknown>>(options?: ElementQueryOptions): Promise<NeptuneEdge<P>[]>;
+    /** `g.E(id).drop().iterate()`. No-op (does not throw) if the edge doesn't exist. */
+    dropEdge(id: NeptuneId): Promise<void>;
+    /**
+     * `g.V(id).out(edgeLabel)` (or `.in_()`/`.both()` per `options.direction`,
+     * default `'out'`), projected with `elementMap()`. The common
+     * "one-hop neighbors" query — for multi-hop traversals, path-finding, or
+     * anything else Gremlin's step library covers beyond one hop, use
+     * `traversal()` directly.
+     */
+    neighbors<P extends Record<string, unknown> = Record<string, unknown>>(id: NeptuneId, options?: NeighborOptions): Promise<NeptuneVertex<P>[]>;
+    private applyElementFilters;
+}
+export default NeptuneStore;

package/dist/nosql/neptune/index.js

@@ -49,9 +49,6 @@
  *
  * See the README in this directory for a worked example of option 2.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeptuneStore = exports.NeptuneError = void 0;
 // The `gremlin` package ships no TypeScript declarations, so this import
@@ -59,7 +56,23 @@ exports.NeptuneStore = exports.NeptuneError = void 0;
 // which is exactly the escape hatch intended for cases like this). All
 // gremlin types used below (`GraphTraversalSource`, `Traversal`, ...) are
 // therefore documented in comments rather than enforced by the compiler.
-const gremlin_1 = __importDefault(require("gremlin"));
+// Lazily-loaded `gremlin` package. Required only when a connection is opened,
+// so importing this ORM never loads the gremlin driver. The package ships no
+// TypeScript declarations, so the module is typed as `any` (see note above).
+let gremlinModule = null;
+function loadGremlin() {
+    if (!gremlinModule) {
+        try {
+            gremlinModule = require('gremlin');
+        }
+        catch (err) {
+            throw new Error("The 'gremlin' package is required to use the Neptune store but could not be loaded. " +
+                'Install it with `npm install gremlin`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return gremlinModule;
+}
 const errors_1 = require("../../errors");
 /** `DatabaseError` subclass used for all Neptune/Gremlin failures wrapped by this store. */
 class NeptuneError extends errors_1.DatabaseError {
@@ -166,10 +179,11 @@ class NeptuneStore {
                 headers,
                 ...this.options.connectionOptions,
             };
-            this.connection = new gremlin_1.default.driver.DriverRemoteConnection(url, connectionOptions);
+            const gremlinLib = loadGremlin();
+            this.connection = new gremlinLib.driver.DriverRemoteConnection(url, connectionOptions);
             await this.connection.open();
-            this.g = gremlin_1.default.process.AnonymousTraversalSource.traversal().with_(this.connection);
-            this.client = new gremlin_1.default.driver.Client(url, connectionOptions);
+            this.g = gremlinLib.process.AnonymousTraversalSource.traversal().with_(this.connection);
+            this.client = new gremlinLib.driver.Client(url, connectionOptions);
             await this.client.open();
             this.connected = true;
         }
@@ -248,7 +262,7 @@ class NeptuneStore {
     async traversal(build) {
         const g = this.requireG();
         try {
-            const t = build(g, gremlin_1.default.process.statics);
+            const t = build(g, loadGremlin().process.statics);
             const list = await t.toList();
             return list.map(normalizeValue);
         }
@@ -373,7 +387,7 @@ class NeptuneStore {
     async addEdge(fromId, label, toId, properties = {}) {
         const g = this.requireG();
         try {
-            let t = g.V(fromId).addE(label).to(gremlin_1.default.process.statics.V(toId));
+            let t = g.V(fromId).addE(label).to(loadGremlin().process.statics.V(toId));
             for (const [key, value] of Object.entries(properties)) {
                 t = t.property(key, value);
             }

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

@@ -0,0 +1,93 @@
+/**
+ * NSQ topic/channel queue store.
+ *
+ * NSQ is a realtime distributed messaging platform. Producers `publish`
+ * messages to a *topic* via a `Writer`; consumers create a `Reader` bound to
+ * a topic + *channel* and handle each delivered message (calling
+ * `msg.finish()`/`msg.requeue()`). NSQ distributes a topic's messages across
+ * all channels, and load-balances within a channel. 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 NSQ's real
+ * publish/subscribe operations instead.
+ *
+ * Uses the `nsqjs` 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 driver module
+ * (providing `Writer` and `Reader` constructors) can be injected via
+ * `NsqStoreOptions.client`, in which case `connect()` adopts it and skips the
+ * `require` entirely (used by the unit tests to inject mocks).
+ */
+import type { NoSqlStore } from '../store';
+/** Connection options for `NsqStore`. */
+export interface NsqStoreOptions {
+    /** nsqd host for the producer `Writer`. Defaults to `'127.0.0.1'`. */
+    nsqdHost?: string;
+    /** nsqd TCP port for the producer `Writer`. Defaults to `4150`. */
+    nsqdPort?: number;
+    /**
+     * Reader connection options: typically `{ lookupdHTTPAddresses }` or
+     * `{ nsqdTCPAddresses }`. Passed straight to every `Reader`.
+     */
+    readerOptions?: any;
+    /**
+     * A pre-built `nsqjs` module (or a stand-in exposing `Writer` and `Reader`
+     * constructors). When provided, `connect()` adopts it and does not
+     * `require('nsqjs')` — used for injecting mocks in tests.
+     */
+    client?: any;
+}
+/** Options for `process()` (subscribing a Reader to a topic). */
+export interface NsqProcessOptions {
+    /** The NSQ channel to consume on. Defaults to `'default'`. */
+    channel?: string;
+    /** Additional `nsqjs` Reader options, merged over `readerOptions`. */
+    [key: string]: any;
+}
+/**
+ * `NsqStore` wraps a single producer `Writer` plus a pool of consumer
+ * `Reader`s (keyed by `topic/channel`) and exposes the common queue surface.
+ * NSQ has no server-side job registry, so `getJob()`/`remove()` (which imply
+ * addressing a job by id) are not supported and throw.
+ */
+export declare class NsqStore implements NoSqlStore {
+    readonly name = "nsq";
+    readonly library = "nsqjs";
+    private readonly options;
+    private driver;
+    private writer;
+    private connected;
+    private readonly readers;
+    constructor(options?: NsqStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying producer `Writer` for operations not wrapped here. */
+    getClient(): any;
+    private requireWriter;
+    /**
+     * Publish a message to a topic via the producer `Writer`. The payload is
+     * JSON-serialized (strings/Buffers pass through). NSQ does not return a
+     * client-visible job id, so this resolves to `null`.
+     */
+    enqueue(queue: string, jobData: unknown): Promise<null>;
+    /**
+     * Subscribe a `Reader` to `queue` (topic) on a channel and invoke
+     * `handler(msg)` for each delivered message. One reader is cached per
+     * `topic/channel`; a repeat `process()` on the same pair returns it.
+     */
+    process(queue: string, handler: (msg: any) => void | Promise<void>, opts?: NsqProcessOptions): Promise<any>;
+    /** Not supported: NSQ exposes no server-side lookup of a message by id. */
+    getJob(_queue: string, _id: string): Promise<never>;
+    /** Not supported: NSQ messages are acknowledged via `finish()`, not removed by id. */
+    remove(_queue: string, _id: string): Promise<never>;
+    /**
+     * Return a lightweight local view of consumers for a topic: the number of
+     * active `Reader`s this store has bound to it. (NSQ's authoritative stats
+     * live in nsqd's HTTP `/stats` endpoint, not the client library.)
+     */
+    stats(queue: string): Promise<{
+        topic: string;
+        readers: number;
+    }>;
+}
+export default NsqStore;

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

@@ -0,0 +1,97 @@
+/**
+ * OpenSearch store implementation.
+ *
+ * OpenSearch is a distributed document store forked from Elasticsearch 7.10.
+ * Like Elasticsearch it is built around an inverted index and a JSON-based
+ * Query DSL (`match`/`term`/`bool`/`range` queries, aggregations, sorting)
+ * rather than SQL: no `JOIN`, no transaction log, schema-flexible documents.
+ * It therefore does not fit the SQL-shaped `Dialect` interface used by the
+ * SQL dialects in this repo. Instead it implements the minimal `NoSqlStore`
+ * marker interface (`src/nosql/store.ts`) and exposes OpenSearch's real
+ * capabilities grouped by concern: connection lifecycle, index management,
+ * document CRUD (single + bulk), and search.
+ *
+ * Uses the official `@opensearch-project/opensearch` driver. The driver is
+ * loaded lazily via `require` so importing this module does not force the
+ * dependency to be resolved unless an OpenSearch store is actually
+ * constructed. For unit-testing without a live cluster, the constructor also
+ * accepts an already-built `client`, which `connect()` will use as-is instead
+ * of instantiating a new one.
+ *
+ * Note: the OpenSearch client wraps every response in an envelope and puts
+ * the actual payload under `.body` (`{ body, statusCode, headers, meta }`),
+ * so each wrapper here reads through `response.body`.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * Connection options for `OpenSearchStore`.
+ *
+ * `node` (or `nodes`), `auth`, and `ssl` are passed straight through to the
+ * driver's `new Client(...)`. Pass `client` to inject an already-built client
+ * instance (used in tests and when the caller wants full control over driver
+ * configuration); when present, `node`/`auth`/`ssl` are ignored.
+ */
+export interface OpenSearchStoreOptions {
+    /** URL of a single OpenSearch node, e.g. `https://localhost:9200`. */
+    node?: string;
+    /** URLs of multiple OpenSearch nodes for client-side round-robin. */
+    nodes?: string | string[];
+    /** Basic-auth credentials (`{ username, password }`) or other driver-supported auth. */
+    auth?: Record<string, unknown>;
+    /** TLS options passed to the driver (e.g. `{ rejectUnauthorized: false }`). */
+    ssl?: Record<string, unknown>;
+    /** An already-constructed OpenSearch client to use instead of building one. */
+    client?: any;
+    /** Any additional options passed through to the driver's `Client`. */
+    [key: string]: unknown;
+}
+/** A single operation for `bulk()`, in the driver's NDJSON action/source shape. */
+export type BulkOperation = Record<string, unknown>;
+/** Result of a `bulk()` call, mirroring the driver's response body. */
+export interface BulkResult {
+    errors: boolean;
+    items: Record<string, unknown>[];
+    took: number;
+}
+/**
+ * `OpenSearchStore` wraps the official `@opensearch-project/opensearch`
+ * client and exposes index management, document CRUD (single + bulk), and
+ * Query-DSL search as a typed, promise-based API.
+ */
+export declare class OpenSearchStore implements NoSqlStore {
+    readonly name = "opensearch";
+    readonly library = "@opensearch-project/opensearch";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options: OpenSearchStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `@opensearch-project/opensearch` client for anything not wrapped here. */
+    getClient(): any;
+    private requireClient;
+    private exec;
+    /** Create an index, optionally with a body (mappings/settings/aliases). */
+    createIndex(index: string, body?: Record<string, unknown>): Promise<void>;
+    /** Delete an index. */
+    deleteIndex(index: string): Promise<void>;
+    /** Whether an index exists. */
+    indexExists(index: string): Promise<boolean>;
+    /** Index (create or overwrite) a document under an explicit `id`. */
+    indexDocument(index: string, id: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Get a document's `_source` by ID. */
+    get<T = Record<string, unknown>>(index: string, id: string): Promise<T | undefined>;
+    /** Run a Query-DSL search and return the `hits` object from the response. */
+    search<T = Record<string, unknown>>(index: string, query: Record<string, unknown>): Promise<T>;
+    /** Delete a document by ID. */
+    deleteDocument(index: string, id: string): Promise<Record<string, unknown>>;
+    /**
+     * Run a batch of operations (already in the driver's NDJSON action/source
+     * array form) in a single request. The real `_bulk` API rejects an empty
+     * request body outright, so short-circuit zero operations to a trivial
+     * no-op result rather than surfacing that as an error.
+     */
+    bulk(operations: BulkOperation[]): Promise<BulkResult>;
+}
+export default OpenSearchStore;

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

@@ -0,0 +1,72 @@
+/**
+ * OrientDB store implementation for the Prorm NoSQL layer.
+ *
+ * OrientDB is a multi-model database combining document, graph, key/value and
+ * object models, queried with an extended SQL dialect over a session. While
+ * its query language is SQL-like, it does not fit Prorm's SQL-shaped
+ * `Dialect` interface (no shared identifier escaping / DDL builder), so this
+ * class implements the minimal `NoSqlStore` marker interface for connection
+ * lifecycle and exposes OrientDB's real session `command`/`query` API through
+ * a small document-CRUD convenience layer.
+ *
+ * Uses the official `orientjs` driver. 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 session via
+ * `options.client`, which bypasses the lazy `require` entirely - no real
+ * driver and no network are needed.
+ */
+import { NoSqlStore } from '../store';
+/** A native OrientDB session/db handle, left untyped because the driver is an
+ * optional dependency not imported here. */
+type OrientSession = any;
+/**
+ * Connection options for `OrientDbStore`.
+ *
+ * `host`/`port` locate the server; `database`/`username`/`password` open a
+ * session against a specific database. When a pre-built `client` (an open
+ * session) is supplied (e.g. in tests), `connect()` uses it directly and skips
+ * loading the `orientjs` driver.
+ */
+export interface OrientDbStoreOptions {
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    /** A pre-built OrientDB session to use instead of the driver. */
+    client?: OrientSession;
+}
+/** Options accepted by {@link OrientDbStore.query}. */
+export interface OrientDbQueryOptions {
+    /** Named/positional parameters bound into the statement. */
+    params?: Record<string, unknown> | unknown[];
+    [key: string]: unknown;
+}
+export declare class OrientDbStore implements NoSqlStore {
+    readonly name = "orientdb";
+    readonly library = "orientjs";
+    private readonly options;
+    private orientClient;
+    private session;
+    private connected;
+    constructor(options?: OrientDbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getClient(): OrientSession;
+    private requireSession;
+    /** Insert a document into `collection` (class); returns its `@rid`/id. */
+    insert(collection: string, doc: Record<string, unknown>): Promise<unknown>;
+    /** Fetch a document by `@rid`. */
+    get(collection: string, id: string): Promise<unknown>;
+    /** Merge `patch` into an existing document identified by `@rid`. */
+    update(collection: string, id: string, patch: Record<string, unknown>): Promise<unknown>;
+    /** Delete a document identified by `@rid`. */
+    delete(collection: string, id: string): Promise<unknown>;
+    /**
+     * Run an OrientDB SQL `statement` and return the resulting rows.
+     * `options.params` binds parameters into the statement.
+     */
+    query(collection: string, statement: string, options?: OrientDbQueryOptions): Promise<unknown[]>;
+}
+export default OrientDbStore;