ts-prorm-orm 1.1.0

package/dist/nosql/neptune/index.js

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * 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.
+ */
+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
+// is implicitly `any` (the repo's tsconfig has `noImplicitAny: false`,
+// 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"));
+const errors_1 = require("../../errors");
+/** `DatabaseError` subclass used for all Neptune/Gremlin failures wrapped by this store. */
+class NeptuneError extends errors_1.DatabaseError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = 'NeptuneError';
+    }
+}
+exports.NeptuneError = NeptuneError;
+/** Recursively converts Gremlin's `Map`/`Array` result shapes (from `valueMap()`/`elementMap()`) into plain JS objects/arrays. */
+function normalizeValue(value) {
+    if (value instanceof Map) {
+        const obj = {};
+        for (const [key, val] of value.entries()) {
+            obj[String(key)] = normalizeValue(val);
+        }
+        return obj;
+    }
+    if (Array.isArray(value)) {
+        return value.map(normalizeValue);
+    }
+    return value;
+}
+/** Splits a normalized `elementMap()` result into a `NeptuneVertex`. */
+function toVertex(normalized) {
+    const { id, label, ...properties } = normalized;
+    return { id: id, label: String(label), properties };
+}
+/** Splits a normalized `elementMap()` result into a `NeptuneEdge`. `IN`/`OUT` are the endpoint vertex IDs Gremlin's edge `elementMap()` reports them under. */
+function toEdge(normalized) {
+    const { id, label, IN, OUT, ...properties } = normalized;
+    return {
+        id: id,
+        label: String(label),
+        outV: OUT,
+        inV: IN,
+        properties,
+    };
+}
+function wrapConnectionError(err, endpoint) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return new errors_1.ConnectionError(`Unable to connect to Neptune: ${parent.message}`, {
+        parent,
+        database: 'neptune',
+        host: endpoint,
+    });
+}
+function wrapNeptuneError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return new NeptuneError(`Neptune ${action} failed: ${parent.message}`, {
+        parent,
+        original: parent.message,
+    });
+}
+/**
+ * `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).
+ */
+class NeptuneStore {
+    constructor(options = {}) {
+        this.name = 'neptune';
+        this.library = 'gremlin';
+        this.connection = null;
+        this.g = null;
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    resolveUrl() {
+        if (this.options.url) {
+            return this.options.url;
+        }
+        if (!this.options.endpoint) {
+            throw new errors_1.ConnectionError('NeptuneStore requires either `url` or `endpoint` to connect', {
+                database: 'neptune',
+            });
+        }
+        const scheme = this.options.useSsl === false ? 'ws' : 'wss';
+        const port = this.options.port ?? 8182;
+        return `${scheme}://${this.options.endpoint}:${port}/gremlin`;
+    }
+    async resolveHeaders() {
+        const provided = this.options.authHeaderProvider ? await this.options.authHeaderProvider() : undefined;
+        const merged = { ...this.options.headers, ...provided };
+        return Object.keys(merged).length > 0 ? merged : undefined;
+    }
+    async connect() {
+        const url = this.resolveUrl();
+        try {
+            const headers = await this.resolveHeaders();
+            const connectionOptions = {
+                traversalSource: this.options.traversalSource ?? 'g',
+                rejectUnauthorized: this.options.rejectUnauthorized,
+                headers,
+                ...this.options.connectionOptions,
+            };
+            this.connection = new gremlin_1.default.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);
+            await this.client.open();
+            this.connected = true;
+        }
+        catch (err) {
+            await this.safeCloseAll();
+            this.connected = false;
+            throw wrapConnectionError(err, this.options.endpoint ?? url);
+        }
+    }
+    async safeCloseAll() {
+        try {
+            await this.client?.close();
+        }
+        catch {
+            // ignore - we're already tearing down after a failure
+        }
+        try {
+            await this.connection?.close();
+        }
+        catch {
+            // ignore - we're already tearing down after a failure
+        }
+        this.client = null;
+        this.connection = null;
+        this.g = null;
+    }
+    async disconnect() {
+        await this.safeCloseAll();
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.connection !== null && this.connection.isOpen === true;
+    }
+    /** Returns the underlying `GraphTraversalSource` (`g`) for building traversals not wrapped below. */
+    getClient() {
+        return this.requireG();
+    }
+    /** Access to the raw `DriverRemoteConnection`, e.g. to inspect `isOpen` directly. */
+    getConnection() {
+        if (!this.connection) {
+            throw new errors_1.ConnectionError('Neptune client is not connected. Call connect() first.', {
+                database: 'neptune',
+            });
+        }
+        return this.connection;
+    }
+    requireG() {
+        if (!this.g || !this.connected) {
+            throw new errors_1.ConnectionError('Neptune client is not connected. Call connect() first.', {
+                database: 'neptune',
+            });
+        }
+        return this.g;
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('Neptune client is not connected. Call connect() first.', {
+                database: 'neptune',
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // Raw Gremlin
+    // ---------------------------------------------------------------------
+    /**
+     * 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'));
+     */
+    async traversal(build) {
+        const g = this.requireG();
+        try {
+            const t = build(g, gremlin_1.default.process.statics);
+            const list = await t.toList();
+            return list.map(normalizeValue);
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, 'traversal');
+        }
+    }
+    /**
+     * 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.
+     */
+    async submit(script, bindings = {}) {
+        const client = this.requireClient();
+        try {
+            const resultSet = await client.submit(script, bindings);
+            const list = typeof resultSet.toArray === 'function' ? resultSet.toArray() : resultSet;
+            return list.map(normalizeValue);
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `script submit ('${script}')`);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Vertex CRUD
+    // ---------------------------------------------------------------------
+    /** `addV(label)` + a `property(key, value)` step per entry in `properties`, returning the created vertex via `elementMap()`. */
+    async addVertex(label, properties = {}) {
+        const g = this.requireG();
+        try {
+            let t = g.addV(label);
+            for (const [key, value] of Object.entries(properties)) {
+                t = t.property(key, value);
+            }
+            const { value } = await t.elementMap().next();
+            return toVertex(normalizeValue(value));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `addVertex('${label}')`);
+        }
+    }
+    /** `g.V(id).elementMap().next()` — returns `undefined` if no vertex with that ID exists. */
+    async getVertex(id) {
+        const g = this.requireG();
+        try {
+            const { value, done } = await g.V(id).elementMap().next();
+            if (done || value === undefined || value === null) {
+                return undefined;
+            }
+            return toVertex(normalizeValue(value));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `getVertex('${String(id)}')`);
+        }
+    }
+    /** `g.V()` filtered by `options.label`/`options.has`/`options.limit`, projected with `elementMap()`. */
+    async findVertices(options = {}) {
+        const g = this.requireG();
+        try {
+            let t = g.V();
+            t = this.applyElementFilters(t, options);
+            const list = await t.elementMap().toList();
+            return list.map((v) => toVertex(normalizeValue(v)));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, 'findVertices');
+        }
+    }
+    /** Same filters as `findVertices()`, terminated with `count()` instead of materializing elements. */
+    async countVertices(options = {}) {
+        const g = this.requireG();
+        try {
+            let t = g.V();
+            t = this.applyElementFilters(t, options);
+            const { value } = await t.count().next();
+            return Number(value);
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, 'countVertices');
+        }
+    }
+    /** `g.V(id)` + a `property(key, value)` step per entry in `properties` (existing properties keep their value unless overwritten here), returning the updated vertex. */
+    async updateVertex(id, properties) {
+        const g = this.requireG();
+        try {
+            let t = g.V(id);
+            for (const [key, value] of Object.entries(properties)) {
+                t = t.property(key, value);
+            }
+            const { value, done } = await t.elementMap().next();
+            if (done || value === undefined || value === null) {
+                return undefined;
+            }
+            return toVertex(normalizeValue(value));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `updateVertex('${String(id)}')`);
+        }
+    }
+    /** `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. */
+    async dropVertex(id) {
+        const g = this.requireG();
+        try {
+            await g.V(id).drop().iterate();
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `dropVertex('${String(id)}')`);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Edge CRUD
+    // ---------------------------------------------------------------------
+    /**
+     * `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`).
+     */
+    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));
+            for (const [key, value] of Object.entries(properties)) {
+                t = t.property(key, value);
+            }
+            const { value } = await t.elementMap().next();
+            return toEdge(normalizeValue(value));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `addEdge('${label}')`);
+        }
+    }
+    /** `g.E(id).elementMap().next()` — returns `undefined` if no edge with that ID exists. */
+    async getEdge(id) {
+        const g = this.requireG();
+        try {
+            const { value, done } = await g.E(id).elementMap().next();
+            if (done || value === undefined || value === null) {
+                return undefined;
+            }
+            return toEdge(normalizeValue(value));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `getEdge('${String(id)}')`);
+        }
+    }
+    /** `g.E()` filtered by `options.label`/`options.has`/`options.limit`, projected with `elementMap()`. */
+    async findEdges(options = {}) {
+        const g = this.requireG();
+        try {
+            let t = g.E();
+            t = this.applyElementFilters(t, options);
+            const list = await t.elementMap().toList();
+            return list.map((v) => toEdge(normalizeValue(v)));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, 'findEdges');
+        }
+    }
+    /** `g.E(id).drop().iterate()`. No-op (does not throw) if the edge doesn't exist. */
+    async dropEdge(id) {
+        const g = this.requireG();
+        try {
+            await g.E(id).drop().iterate();
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `dropEdge('${String(id)}')`);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Traversal convenience
+    // ---------------------------------------------------------------------
+    /**
+     * `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.
+     */
+    async neighbors(id, options = {}) {
+        const g = this.requireG();
+        const direction = options.direction ?? 'out';
+        try {
+            let t = g.V(id);
+            const step = direction === 'in' ? 'in_' : direction === 'both' ? 'both' : 'out';
+            t = options.edgeLabel ? t[step](options.edgeLabel) : t[step]();
+            if (options.limit !== undefined) {
+                t = t.limit(options.limit);
+            }
+            const list = await t.elementMap().toList();
+            return list.map((v) => toVertex(normalizeValue(v)));
+        }
+        catch (err) {
+            throw wrapNeptuneError(err, `neighbors('${String(id)}')`);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Internal helpers
+    // ---------------------------------------------------------------------
+    applyElementFilters(t, options) {
+        if (options.label) {
+            t = t.hasLabel(options.label);
+        }
+        if (options.has) {
+            for (const [key, value] of Object.entries(options.has)) {
+                t = t.has(key, value);
+            }
+        }
+        if (options.limit !== undefined) {
+            t = t.limit(options.limit);
+        }
+        return t;
+    }
+}
+exports.NeptuneStore = NeptuneStore;
+exports.default = NeptuneStore;

package/dist/nosql/nsq/index.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NsqStore = void 0;
+const errors_1 = require("../../errors");
+function wrapConnectionError(err) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    const message = /econnrefused/i.test(parent.message)
+        ? 'Connection refused'
+        : `Unable to connect to NSQ: ${parent.message}`;
+    return new errors_1.ConnectionError(message, { parent, database: 'nsq' });
+}
+function wrapDatabaseError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `NSQ ${action} failed: ${parent.message}` });
+}
+/**
+ * `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.
+ */
+class NsqStore {
+    constructor(options = {}) {
+        this.name = 'nsq';
+        this.library = 'nsqjs';
+        this.driver = null;
+        this.writer = null;
+        this.connected = false;
+        this.readers = new Map();
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.writer) {
+            return;
+        }
+        try {
+            this.driver = this.options.client != null ? this.options.client : require('nsqjs');
+            const host = this.options.nsqdHost || '127.0.0.1';
+            const port = this.options.nsqdPort || 4150;
+            this.writer = new this.driver.Writer(host, port);
+            // A real nsqjs Writer connects asynchronously and emits 'ready'; a mock
+            // Writer may expose neither, so only wait when both are present.
+            if (typeof this.writer.connect === 'function' &&
+                typeof this.writer.on === 'function') {
+                await new Promise((resolve, reject) => {
+                    this.writer.on('ready', () => resolve());
+                    this.writer.on('error', (err) => reject(err));
+                    this.writer.connect();
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.writer = null;
+            this.driver = null;
+            this.connected = false;
+            throw wrapConnectionError(err);
+        }
+    }
+    async disconnect() {
+        for (const reader of this.readers.values()) {
+            try {
+                if (reader && typeof reader.close === 'function')
+                    reader.close();
+            }
+            catch {
+                // Ignore teardown errors.
+            }
+        }
+        this.readers.clear();
+        try {
+            if (this.writer && typeof this.writer.close === 'function')
+                this.writer.close();
+        }
+        catch {
+            // Ignore teardown errors.
+        }
+        this.writer = null;
+        this.driver = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.writer !== null;
+    }
+    /** Returns the underlying producer `Writer` for operations not wrapped here. */
+    getClient() {
+        return this.requireWriter();
+    }
+    requireWriter() {
+        if (!this.writer) {
+            throw new errors_1.ConnectionError('Not connected to NSQ', { database: 'nsq' });
+        }
+        return this.writer;
+    }
+    // ---------------------------------------------------------------------
+    // Queue operations
+    // ---------------------------------------------------------------------
+    /**
+     * 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`.
+     */
+    async enqueue(queue, jobData) {
+        const writer = this.requireWriter();
+        const message = typeof jobData === 'string' || Buffer.isBuffer(jobData) ? jobData : JSON.stringify(jobData);
+        return new Promise((resolve, reject) => {
+            try {
+                writer.publish(queue, message, (err) => {
+                    if (err)
+                        reject(wrapDatabaseError(err, 'enqueue'));
+                    else
+                        resolve(null);
+                });
+            }
+            catch (err) {
+                reject(wrapDatabaseError(err, 'enqueue'));
+            }
+        });
+    }
+    /**
+     * 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.
+     */
+    async process(queue, handler, opts = {}) {
+        try {
+            const { channel = 'default', ...readerOpts } = opts;
+            const key = `${queue}/${channel}`;
+            const existing = this.readers.get(key);
+            if (existing)
+                return existing;
+            const driver = this.driver;
+            if (!driver) {
+                throw new errors_1.ConnectionError('Not connected to NSQ', { database: 'nsq' });
+            }
+            const reader = new driver.Reader(queue, channel, {
+                ...(this.options.readerOptions || {}),
+                ...readerOpts,
+            });
+            reader.on('message', (msg) => handler(msg));
+            reader.connect();
+            this.readers.set(key, reader);
+            return reader;
+        }
+        catch (err) {
+            if (err instanceof errors_1.ConnectionError)
+                throw err;
+            throw wrapDatabaseError(err, 'process');
+        }
+    }
+    /** Not supported: NSQ exposes no server-side lookup of a message by id. */
+    async getJob(_queue, _id) {
+        throw new errors_1.DatabaseError('NSQ does not support getJob (no addressable job ids)', {
+            code: undefined,
+        });
+    }
+    /** Not supported: NSQ messages are acknowledged via `finish()`, not removed by id. */
+    async remove(_queue, _id) {
+        throw new errors_1.DatabaseError('NSQ does not support remove (use msg.finish() in the handler)', {
+            code: undefined,
+        });
+    }
+    /**
+     * 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.)
+     */
+    async stats(queue) {
+        let count = 0;
+        for (const key of this.readers.keys()) {
+            if (key.startsWith(`${queue}/`))
+                count++;
+        }
+        return { topic: queue, readers: count };
+    }
+}
+exports.NsqStore = NsqStore;
+exports.default = NsqStore;