ts-prorm-orm 1.1.0

package/dist/nosql/r2/index.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.R2Store = void 0;
+/**
+ * Cloudflare R2 object-storage store.
+ *
+ * R2 is Cloudflare's S3-compatible object store: like Amazon S3 it has no
+ * query language, no rows, and no SQL-shaped access pattern — data is opaque
+ * objects (byte bodies plus metadata) addressed by a `(bucket, key)` pair,
+ * where the "key" is a flat string that only *looks* like a path
+ * (`foo/bar/baz.json`); R2 has no real directories, just an optional key
+ * `prefix` you can filter listings by. None of that fits the SQL-shaped
+ * `Dialect` interface, so this store implements the minimal `NoSqlStore`
+ * marker interface (`src/nosql/store.ts`) and exposes object-level operations
+ * directly.
+ *
+ * Because R2 speaks the S3 wire protocol, this store is built on AWS SDK v3
+ * (`@aws-sdk/client-s3`) exactly like `S3Store`: an `S3Client` uses the
+ * command pattern — you construct a command object (`new PutObjectCommand(
+ * input)`) and hand it to `client.send(command)`. The only differences from a
+ * plain S3 connection are R2-specific client settings: R2 has no regions, so
+ * `region` is the sentinel `'auto'`; requests go to an account-specific
+ * `endpoint` (e.g. `https://<account_id>.r2.cloudflarestorage.com`); and
+ * path-style addressing is required (`forcePathStyle: true`).
+ *
+ * The SDK is loaded lazily inside `connect()` (via `require`) rather than a
+ * top-level import so that importing this module doesn't hard-require the
+ * `@aws-sdk/client-s3` package unless an R2 store is actually connected — and
+ * so tests can inject a pre-built mock `client` and never load the SDK at all.
+ */
+const errors_1 = require("../../errors");
+/**
+ * Cloudflare R2 store, implementing the minimal `NoSqlStore` marker interface.
+ * Unlike the SQL dialects there is no `query(sql)` — R2's operations are
+ * object-shaped (Put/Get/Delete/List/Head) and that shape is preserved here
+ * rather than forced into a SQL string.
+ */
+class R2Store {
+    constructor(options = {}) {
+        this.name = 'r2';
+        this.library = '@aws-sdk/client-s3';
+        this.client = null;
+        this.aws = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // NoSqlStore lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        try {
+            if (this.options.client) {
+                // A pre-built client was injected (mock or custom). Use it directly
+                // and don't require the SDK at all. We still best-effort lazy-load the
+                // SDK for the command constructors if it happens to be installed; if
+                // not, the command classes are loaded on demand in each method.
+                this.client = this.options.client;
+                this.tryLoadSdk();
+            }
+            else {
+                const aws = require('@aws-sdk/client-s3');
+                this.aws = aws;
+                this.client = new aws.S3Client({
+                    // R2 has no regions; the SDK still requires a region, and R2
+                    // expects the sentinel 'auto'.
+                    region: this.options.region ?? 'auto',
+                    // R2 uses an account-specific endpoint rather than the AWS default.
+                    endpoint: this.options.endpoint,
+                    credentials: this.options.credentials,
+                    // R2 requires path-style addressing (endpoint/bucket/key).
+                    forcePathStyle: true,
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.connected = false;
+            this.client = null;
+            this.aws = null;
+            throw new errors_1.ConnectionError(`Failed to connect to R2: ${err instanceof Error ? err.message : String(err)}`, { parent: err instanceof Error ? err : undefined });
+        }
+    }
+    /**
+     * Attempt to lazy-load `@aws-sdk/client-s3` for its command constructors.
+     * Best-effort: when a client was injected (e.g. a test mock) the SDK may
+     * not be installed, so a failure here is swallowed and the command classes
+     * are loaded on demand instead (see `command()`).
+     */
+    tryLoadSdk() {
+        if (this.aws)
+            return;
+        try {
+            this.aws = require('@aws-sdk/client-s3');
+        }
+        catch {
+            this.aws = null;
+        }
+    }
+    async disconnect() {
+        try {
+            this.client?.destroy?.();
+        }
+        finally {
+            this.client = null;
+            this.aws = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `S3Client` (loosely typed) for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('R2 client is not connected. Call connect() first.');
+        }
+        return this.client;
+    }
+    /**
+     * Resolve an S3 command constructor by name from the (lazily loaded) SDK,
+     * so that with an injected mock client we only load `@aws-sdk/client-s3`
+     * the first time a command is actually built. Throws a `ConnectionError`
+     * if the SDK genuinely can't be resolved.
+     */
+    command(name, input) {
+        if (!this.aws) {
+            this.tryLoadSdk();
+        }
+        const Ctor = this.aws?.[name];
+        if (typeof Ctor !== 'function') {
+            throw new errors_1.ConnectionError(`R2 command '${name}' is unavailable: '@aws-sdk/client-s3' could not be loaded.`);
+        }
+        return new Ctor(input);
+    }
+    /** Wraps an AWS SDK failure in a `DatabaseError`, preserving the original error. */
+    wrapError(action, err) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        const name = parent.name ? ` (${parent.name})` : '';
+        return new errors_1.DatabaseError(`R2 ${action} failed${name}: ${parent.message}`, {
+            parent,
+            original: parent.message,
+        });
+    }
+    // ---------------------------------------------------------------------
+    // Object operations (AWS v3 command pattern via client.send)
+    // ---------------------------------------------------------------------
+    /** `PutObject` — store an object's body (and optional metadata) under `bucket`/`key`. */
+    async putObject(bucket, key, body, options = {}) {
+        const client = this.requireClient();
+        try {
+            const result = await client.send(this.command('PutObjectCommand', {
+                Bucket: bucket,
+                Key: key,
+                Body: body,
+                ContentType: options.contentType,
+                Metadata: options.metadata,
+                CacheControl: options.cacheControl,
+                ContentEncoding: options.contentEncoding,
+            }));
+            return { etag: result?.ETag, versionId: result?.VersionId };
+        }
+        catch (err) {
+            throw this.wrapError(`PutObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /** `GetObject` — fetch an object's body and metadata. */
+    async getObject(bucket, key) {
+        const client = this.requireClient();
+        try {
+            const result = await client.send(this.command('GetObjectCommand', { Bucket: bucket, Key: key }));
+            return {
+                body: result?.Body,
+                contentType: result?.ContentType,
+                contentLength: result?.ContentLength,
+                etag: result?.ETag,
+                lastModified: result?.LastModified,
+                metadata: result?.Metadata,
+            };
+        }
+        catch (err) {
+            throw this.wrapError(`GetObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /** `DeleteObject` — remove an object. Succeeds even if the key doesn't exist. */
+    async deleteObject(bucket, key) {
+        const client = this.requireClient();
+        try {
+            await client.send(this.command('DeleteObjectCommand', { Bucket: bucket, Key: key }));
+        }
+        catch (err) {
+            throw this.wrapError(`DeleteObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /**
+     * `ListObjectsV2` — list objects in `bucket`, optionally restricted to
+     * those whose key starts with `prefix`. A single call returns at most
+     * 1000 objects; use `result.nextContinuationToken` (via the raw client)
+     * to page beyond that.
+     */
+    async listObjects(bucket, prefix) {
+        const client = this.requireClient();
+        try {
+            const result = await client.send(this.command('ListObjectsV2Command', { Bucket: bucket, Prefix: prefix }));
+            const contents = result?.Contents ?? [];
+            return {
+                objects: contents.map((o) => ({
+                    key: o?.Key,
+                    size: o?.Size,
+                    etag: o?.ETag,
+                    lastModified: o?.LastModified,
+                })),
+                isTruncated: Boolean(result?.IsTruncated),
+                nextContinuationToken: result?.NextContinuationToken,
+            };
+        }
+        catch (err) {
+            throw this.wrapError(`ListObjects on '${bucket}'`, err);
+        }
+    }
+    /** `HeadObject` — fetch an object's metadata without its body. Throws (NotFound) if the object doesn't exist. */
+    async headObject(bucket, key) {
+        const client = this.requireClient();
+        try {
+            const result = await client.send(this.command('HeadObjectCommand', { Bucket: bucket, Key: key }));
+            return {
+                contentType: result?.ContentType,
+                contentLength: result?.ContentLength,
+                etag: result?.ETag,
+                lastModified: result?.LastModified,
+                metadata: result?.Metadata,
+            };
+        }
+        catch (err) {
+            throw this.wrapError(`HeadObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /**
+     * Whether an object exists, implemented via `HeadObject`. Returns `false`
+     * when R2 reports the object is missing (a `NotFound` / 404 error) rather
+     * than throwing; any other error (e.g. access denied) is re-thrown.
+     */
+    async objectExists(bucket, key) {
+        try {
+            await this.headObject(bucket, key);
+            return true;
+        }
+        catch (err) {
+            if (this.isNotFound(err)) {
+                return false;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Recognize "object does not exist" errors across the shapes the SDK (and
+     * its wrapped form here) can surface them: the raw error's `.name`
+     * (`NotFound`, `NoSuchKey`), its HTTP status (404), or the wrapped
+     * `DatabaseError`'s `.parent`.
+     */
+    isNotFound(err) {
+        const candidates = [err];
+        const parent = err?.parent;
+        if (parent)
+            candidates.push(parent);
+        for (const c of candidates) {
+            const name = c?.name;
+            if (name === 'NotFound' || name === 'NoSuchKey')
+                return true;
+            const status = c?.$metadata?.httpStatusCode ??
+                c?.statusCode;
+            if (status === 404)
+                return true;
+        }
+        return false;
+    }
+}
+exports.R2Store = R2Store;
+exports.default = R2Store;

package/dist/nosql/rabbitmq/index.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * RabbitMQ (AMQP 0-9-1) store.
+ *
+ * RabbitMQ is a message broker, not a database: there is no query language,
+ * no relational schema, and no `query(sql)` shape. Producers publish
+ * messages to *exchanges*, which route them (by binding key/pattern) into
+ * *queues*, from which *consumers* read. Like the other stores in
+ * `src/nosql/`, this class therefore 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
+ * RabbitMQ's real operations — assert/bind topology, publish, and consume —
+ * directly, mapped onto a single AMQP channel.
+ *
+ * Uses the official `amqplib` driver. `amqplib` is an optional peer of this
+ * ORM and is loaded lazily (via `require`) inside `connect()`, so importing
+ * this module does not require `amqplib` to be installed unless you actually
+ * connect. For tests (and for advanced setups that manage the AMQP
+ * connection themselves), a pre-built connection can be injected via
+ * `RabbitMQStoreOptions.connection`, in which case `connect()` uses it and
+ * skips the `require` entirely.
+ *
+ * ## Message serialization
+ *
+ * AMQP message bodies are raw bytes (`Buffer`). For convenience, both
+ * `sendToQueue()` and `publish()` accept any value: a `Buffer` (or
+ * `Uint8Array`) is sent as-is, a `string` is UTF-8 encoded, and anything
+ * else is serialized with `JSON.stringify` before being wrapped in a
+ * `Buffer`. Consumers receive the raw `amqplib` message object; decode
+ * `msg.content` (a `Buffer`) yourself (e.g. `JSON.parse(msg.content.toString())`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQStore = void 0;
+const errors_1 = require("../../errors");
+/**
+ * Normalize an arbitrary message value into a `Buffer` suitable for the
+ * AMQP wire: `Buffer`/`Uint8Array` pass through, strings are UTF-8 encoded,
+ * everything else is `JSON.stringify`'d.
+ */
+function toBuffer(message) {
+    if (Buffer.isBuffer(message)) {
+        return message;
+    }
+    if (message instanceof Uint8Array) {
+        return Buffer.from(message);
+    }
+    if (typeof message === 'string') {
+        return Buffer.from(message);
+    }
+    return Buffer.from(JSON.stringify(message));
+}
+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 RabbitMQ: ${parent.message}`;
+    return new errors_1.ConnectionError(message, { parent, database: 'rabbitmq' });
+}
+function wrapDatabaseError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `RabbitMQ ${action} failed: ${parent.message}` });
+}
+/**
+ * `RabbitMQStore` wraps a single `amqplib` channel and exposes RabbitMQ's
+ * core AMQP operations: asserting queues/exchanges, binding them, publishing
+ * (to a queue directly or via an exchange), consuming with ack/nack, and
+ * consumer prefetch (QoS).
+ */
+class RabbitMQStore {
+    constructor(options = {}) {
+        this.name = 'rabbitmq';
+        this.library = 'amqplib';
+        this.connection = null;
+        this.channel = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.channel) {
+            return;
+        }
+        try {
+            if (this.options.connection != null) {
+                // Caller-supplied connection: adopt it, don't require the driver.
+                this.connection = this.options.connection;
+            }
+            else {
+                // Lazy-load amqplib only when actually connecting, so importing this
+                // module doesn't hard-require the optional driver to be installed.
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const amqp = require('amqplib');
+                this.connection = await amqp.connect(this.options.url || 'amqp://localhost');
+            }
+            this.channel = await this.connection.createChannel();
+            this.connected = true;
+        }
+        catch (err) {
+            this.channel = null;
+            this.connection = null;
+            this.connected = false;
+            throw wrapConnectionError(err);
+        }
+    }
+    async disconnect() {
+        try {
+            if (this.channel) {
+                await this.channel.close();
+            }
+        }
+        catch {
+            // Ignore channel-close errors; we're tearing down regardless.
+        }
+        try {
+            if (this.connection) {
+                await this.connection.close();
+            }
+        }
+        catch {
+            // Ignore connection-close errors; we're tearing down regardless.
+        }
+        this.channel = null;
+        this.connection = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.channel !== null;
+    }
+    /** Returns the underlying `amqplib` channel for operations not wrapped here. */
+    getClient() {
+        return this.requireChannel();
+    }
+    /** Returns the underlying `amqplib` connection. */
+    getConnection() {
+        if (!this.connection) {
+            throw new errors_1.ConnectionError('Not connected to RabbitMQ', { database: 'rabbitmq' });
+        }
+        return this.connection;
+    }
+    requireChannel() {
+        if (!this.channel) {
+            throw new errors_1.ConnectionError('Not connected to RabbitMQ', { database: 'rabbitmq' });
+        }
+        return this.channel;
+    }
+    async exec(fn, action) {
+        const channel = this.requireChannel();
+        try {
+            return await fn(channel);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, action);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Topology (queues, exchanges, bindings)
+    // ---------------------------------------------------------------------
+    /**
+     * Declare a queue, creating it if it doesn't exist (idempotent). Returns
+     * amqplib's assertion reply (`{ queue, messageCount, consumerCount }`).
+     * Pass `''` as `queue` to have the broker generate a unique name.
+     */
+    async assertQueue(queue, options) {
+        return this.exec((c) => c.assertQueue(queue, options), 'assertQueue');
+    }
+    /**
+     * Declare an exchange of the given `type` (`'direct'`, `'fanout'`,
+     * `'topic'`, `'headers'`), creating it if it doesn't exist (idempotent).
+     */
+    async assertExchange(exchange, type, options) {
+        return this.exec((c) => c.assertExchange(exchange, type, options), 'assertExchange');
+    }
+    /**
+     * Bind `queue` to `exchange` so messages published to `exchange` matching
+     * `pattern` (the routing/binding key) are routed into `queue`.
+     */
+    async bindQueue(queue, exchange, pattern) {
+        return this.exec((c) => c.bindQueue(queue, exchange, pattern), 'bindQueue');
+    }
+    // ---------------------------------------------------------------------
+    // Producing
+    // ---------------------------------------------------------------------
+    /**
+     * Send a message straight to a named `queue` (via the default exchange).
+     * Non-`Buffer` messages are serialized — strings UTF-8 encoded, other
+     * values `JSON.stringify`'d (see the module docs). Returns amqplib's
+     * boolean write result (`false` when the channel's write buffer is full
+     * and you should wait for a `'drain'` event before writing more).
+     */
+    async sendToQueue(queue, message, options) {
+        return this.exec((c) => c.sendToQueue(queue, toBuffer(message), options), 'sendToQueue');
+    }
+    /**
+     * Publish a message to an `exchange` with a `routingKey`; the exchange
+     * routes it to bound queues. Non-`Buffer` messages are serialized like
+     * `sendToQueue()`. Returns amqplib's boolean write result.
+     */
+    async publish(exchange, routingKey, message, options) {
+        return this.exec((c) => c.publish(exchange, routingKey, toBuffer(message), options), 'publish');
+    }
+    // ---------------------------------------------------------------------
+    // Consuming
+    // ---------------------------------------------------------------------
+    /**
+     * Register `handler` to receive each message delivered from `queue`. The
+     * handler is called with the raw amqplib message object (or `null` if the
+     * consumer is cancelled by the broker); decode `msg.content` yourself.
+     * Unless `options.noAck` is set, call `ack(msg)`/`nack(msg)` when done.
+     * Returns amqplib's `{ consumerTag }` reply.
+     */
+    async consume(queue, handler, options) {
+        return this.exec((c) => c.consume(queue, (msg) => handler(msg), options), 'consume');
+    }
+    /** Acknowledge a delivered message so the broker can drop it. */
+    ack(message, allUpTo) {
+        this.requireChannel().ack(message, allUpTo);
+    }
+    /**
+     * Reject a delivered message. By default RabbitMQ requeues it (`requeue`
+     * defaults to `true` in amqplib); pass `requeue = false` to drop or
+     * dead-letter it.
+     */
+    nack(message, allUpTo, requeue) {
+        this.requireChannel().nack(message, allUpTo, requeue);
+    }
+    /**
+     * Set the consumer prefetch (QoS) — the max number of unacknowledged
+     * messages the broker will deliver to consumers on this channel at once.
+     */
+    async prefetch(count, global) {
+        return this.exec((c) => c.prefetch(count, global), 'prefetch');
+    }
+}
+exports.RabbitMQStore = RabbitMQStore;
+exports.default = RabbitMQStore;

package/dist/nosql/ravendb/index.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * RavenDB store implementation for the Prorm NoSQL layer.
+ *
+ * RavenDB is a transactional, multi-model document database with a
+ * unit-of-work session API (store/load/delete + saveChanges) and a fluent,
+ * indexed query builder. It does not fit the SQL-shaped `Dialect` interface,
+ * so this class implements the minimal `NoSqlStore` marker interface for
+ * connection lifecycle and exposes RavenDB's real session CRUD plus `query`
+ * API through a small document-CRUD convenience layer. Each operation opens
+ * its own short-lived session and commits with `saveChanges()`.
+ *
+ * Uses the official `ravendb` 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
+ * `DocumentStore` via `options.client`, which bypasses the lazy `require`
+ * entirely - no real driver and no network are needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RavenDbStore = void 0;
+const errors_1 = require("../../errors");
+class RavenDbStore {
+    constructor(options = {}) {
+        this.name = 'ravendb';
+        this.library = 'ravendb';
+        this.store = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.store) {
+            return;
+        }
+        try {
+            if (this.options.client) {
+                this.store = this.options.client;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mod = require('ravendb');
+                const DocumentStoreCtor = mod.DocumentStore;
+                this.store = new DocumentStoreCtor(this.options.urls, this.options.database);
+            }
+            if (typeof this.store.initialize === 'function') {
+                this.store.initialize();
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.store = null;
+            this.connected = false;
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw new errors_1.ConnectionError(`Unable to connect to RavenDB: ${parent.message}`, {
+                parent,
+                database: 'ravendb',
+            });
+        }
+    }
+    async disconnect() {
+        if (this.store && typeof this.store.dispose === 'function') {
+            try {
+                await this.store.dispose();
+            }
+            catch (err) {
+                throw wrapDatabaseError(err, 'RavenDB disconnect failed');
+            }
+        }
+        this.store = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.store !== null;
+    }
+    getClient() {
+        return this.requireStore();
+    }
+    requireStore() {
+        if (!this.store || !this.connected) {
+            throw new errors_1.ConnectionError('Not connected to RavenDB. Call connect() first.', {
+                database: 'ravendb',
+            });
+        }
+        return this.store;
+    }
+    // ---------------------------------------------------------------------
+    // Document CRUD (unit-of-work sessions)
+    // ---------------------------------------------------------------------
+    /** Store a document in `collection`; returns the id used. */
+    async insert(collection, doc) {
+        const store = this.requireStore();
+        try {
+            const id = (doc.id ?? `${collection}/${genId()}`);
+            const session = store.openSession();
+            await session.store(doc, id);
+            await session.saveChanges();
+            return id;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB insert failed');
+        }
+    }
+    /** Load a document by id. */
+    async get(_collection, id) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            return await session.load(id);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB get failed');
+        }
+    }
+    /** Load, merge `patch`, and save; returns the updated entity. */
+    async update(_collection, id, patch) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            const entity = await session.load(id);
+            const merged = Object.assign(entity ?? {}, patch);
+            await session.saveChanges();
+            return merged;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB update failed');
+        }
+    }
+    /** Delete a document by id. */
+    async delete(_collection, id) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            await session.delete(id);
+            await session.saveChanges();
+            return { id };
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB delete failed');
+        }
+    }
+    /**
+     * Query `collection`. `filter` is a plain object whose entries become
+     * `whereEquals(field, value)` conditions on the session query. Returns all
+     * matched documents.
+     */
+    async query(collection, filter = {}) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            let q = session.query({ collection });
+            for (const [field, value] of Object.entries(filter)) {
+                q = q.whereEquals(field, value);
+            }
+            const results = await q.all();
+            return results ?? [];
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB query failed');
+        }
+    }
+}
+exports.RavenDbStore = RavenDbStore;
+function genId() {
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+function wrapDatabaseError(err, message) {
+    if (err instanceof errors_1.ConnectionError) {
+        return err;
+    }
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `${message}: ${parent.message}` });
+}
+exports.default = RavenDbStore;