ts-prorm-orm 1.1.0

package/dist/nosql/opensearch/index.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * 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`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSearchStore = void 0;
+const errors_1 = require("../../errors");
+function wrapConnectionError(err, node) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    const message = /econnrefused/i.test(parent.message)
+        ? 'Connection refused'
+        : `Unable to connect to OpenSearch: ${parent.message}`;
+    return new errors_1.ConnectionError(message, {
+        parent,
+        database: 'opensearch',
+        host: typeof node === 'string' ? node : undefined,
+    });
+}
+function wrapDatabaseError(err, message) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    const statusCode = err?.meta?.statusCode;
+    const detail = statusCode ? `${parent.message} (HTTP ${statusCode})` : parent.message;
+    const combined = message ? `${message}: ${detail}` : detail;
+    return errors_1.DatabaseError.from(parent, { message: combined });
+}
+/**
+ * `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.
+ */
+class OpenSearchStore {
+    constructor(options) {
+        this.name = 'opensearch';
+        this.library = '@opensearch-project/opensearch';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        let client = this.options.client;
+        if (!client) {
+            // Lazy-load the driver so importing this module doesn't require the
+            // dependency to be present unless a store is actually constructed.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { Client } = require('@opensearch-project/opensearch');
+            client = new Client({
+                node: this.options.node,
+                nodes: this.options.nodes,
+                auth: this.options.auth,
+                ssl: this.options.ssl,
+            });
+        }
+        try {
+            // The driver connects lazily on first request; `ping()` surfaces
+            // connection failures (bad host, refused connection, TLS errors)
+            // immediately instead of on the caller's first real operation.
+            await client.ping();
+            this.client = client;
+            this.connected = true;
+        }
+        catch (err) {
+            await client.close?.().catch?.(() => undefined);
+            this.client = null;
+            this.connected = false;
+            throw wrapConnectionError(err, this.options.node);
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `@opensearch-project/opensearch` client for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to OpenSearch', { database: 'opensearch' });
+        }
+        return this.client;
+    }
+    async exec(fn, action) {
+        const client = this.requireClient();
+        try {
+            return await fn(client);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, `OpenSearch ${action} failed`);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Index management
+    // ---------------------------------------------------------------------
+    /** Create an index, optionally with a body (mappings/settings/aliases). */
+    async createIndex(index, body) {
+        await this.exec((c) => c.indices.create({ index, body }), 'CREATE INDEX');
+    }
+    /** Delete an index. */
+    async deleteIndex(index) {
+        await this.exec((c) => c.indices.delete({ index }), 'DELETE INDEX');
+    }
+    /** Whether an index exists. */
+    async indexExists(index) {
+        const response = await this.exec((c) => c.indices.exists({ index }), 'INDICES EXISTS');
+        return response.body ?? false;
+    }
+    // ---------------------------------------------------------------------
+    // Document CRUD
+    // ---------------------------------------------------------------------
+    /** Index (create or overwrite) a document under an explicit `id`. */
+    async indexDocument(index, id, body) {
+        const response = await this.exec((c) => c.index({ index, id, body }), 'INDEX');
+        return response.body;
+    }
+    /** Get a document's `_source` by ID. */
+    async get(index, id) {
+        const response = await this.exec((c) => c.get({ index, id }), 'GET');
+        return response.body?._source;
+    }
+    /** Run a Query-DSL search and return the `hits` object from the response. */
+    async search(index, query) {
+        const response = await this.exec((c) => c.search({ index, body: query }), 'SEARCH');
+        return response.body?.hits;
+    }
+    /** Delete a document by ID. */
+    async deleteDocument(index, id) {
+        const response = await this.exec((c) => c.delete({ index, id }), 'DELETE');
+        return response.body;
+    }
+    // ---------------------------------------------------------------------
+    // Bulk operations
+    // ---------------------------------------------------------------------
+    /**
+     * 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.
+     */
+    async bulk(operations) {
+        if (operations.length === 0) {
+            return { errors: false, items: [], took: 0 };
+        }
+        const response = await this.exec((c) => c.bulk({ body: operations }), 'BULK');
+        const bodyResult = response.body;
+        return {
+            errors: bodyResult.errors,
+            items: bodyResult.items ?? [],
+            took: bodyResult.took ?? 0,
+        };
+    }
+}
+exports.OpenSearchStore = OpenSearchStore;
+exports.default = OpenSearchStore;

package/dist/nosql/orientdb/index.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrientDbStore = void 0;
+const errors_1 = require("../../errors");
+class OrientDbStore {
+    constructor(options = {}) {
+        this.name = 'orientdb';
+        this.library = 'orientjs';
+        this.orientClient = null;
+        this.session = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.session) {
+            return;
+        }
+        try {
+            if (this.options.client) {
+                this.session = this.options.client;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const orientjs = require('orientjs');
+                const OrientDBClient = orientjs.OrientDBClient ?? orientjs;
+                this.orientClient = await OrientDBClient.connect({
+                    host: this.options.host,
+                    port: this.options.port,
+                });
+                this.session = await this.orientClient.session({
+                    name: this.options.database,
+                    username: this.options.username,
+                    password: this.options.password,
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.session = null;
+            this.orientClient = null;
+            this.connected = false;
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw new errors_1.ConnectionError(`Unable to connect to OrientDB: ${parent.message}`, {
+                parent,
+                database: 'orientdb',
+            });
+        }
+    }
+    async disconnect() {
+        try {
+            if (this.session && typeof this.session.close === 'function') {
+                await this.session.close();
+            }
+            if (this.orientClient && typeof this.orientClient.close === 'function') {
+                await this.orientClient.close();
+            }
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'OrientDB disconnect failed');
+        }
+        finally {
+            this.session = null;
+            this.orientClient = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected && this.session !== null;
+    }
+    getClient() {
+        return this.requireSession();
+    }
+    requireSession() {
+        if (!this.session || !this.connected) {
+            throw new errors_1.ConnectionError('Not connected to OrientDB. Call connect() first.', {
+                database: 'orientdb',
+            });
+        }
+        return this.session;
+    }
+    // ---------------------------------------------------------------------
+    // Document CRUD (extended SQL)
+    // ---------------------------------------------------------------------
+    /** Insert a document into `collection` (class); returns its `@rid`/id. */
+    async insert(collection, doc) {
+        const session = this.requireSession();
+        try {
+            const sql = `INSERT INTO ${collection} CONTENT ${JSON.stringify(doc)}`;
+            const rows = await session.command(sql).all();
+            const record = rows?.[0];
+            const rid = record?.['@rid'];
+            return rid !== undefined ? String(rid) : record?.id;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'OrientDB insert failed');
+        }
+    }
+    /** Fetch a document by `@rid`. */
+    async get(collection, id) {
+        const session = this.requireSession();
+        try {
+            const sql = `SELECT FROM ${collection} WHERE @rid = ${id}`;
+            const rows = await session.query(sql).all();
+            return rows?.[0];
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'OrientDB get failed');
+        }
+    }
+    /** Merge `patch` into an existing document identified by `@rid`. */
+    async update(collection, id, patch) {
+        const session = this.requireSession();
+        try {
+            const sql = `UPDATE ${collection} MERGE ${JSON.stringify(patch)} WHERE @rid = ${id}`;
+            return await session.command(sql).all();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'OrientDB update failed');
+        }
+    }
+    /** Delete a document identified by `@rid`. */
+    async delete(collection, id) {
+        const session = this.requireSession();
+        try {
+            const sql = `DELETE FROM ${collection} WHERE @rid = ${id}`;
+            return await session.command(sql).all();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'OrientDB delete failed');
+        }
+    }
+    /**
+     * Run an OrientDB SQL `statement` and return the resulting rows.
+     * `options.params` binds parameters into the statement.
+     */
+    async query(collection, statement, options = {}) {
+        const session = this.requireSession();
+        try {
+            const rows = await session.query(statement, options).all();
+            return rows ?? [];
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'OrientDB query failed');
+        }
+    }
+}
+exports.OrientDbStore = OrientDbStore;
+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 = OrientDbStore;

package/dist/nosql/papertrail/index.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Papertrail store implementation.
+ *
+ * Papertrail (by SolarWinds) is a hosted log-management service. Logs are
+ * ingested over syslog or an HTTP log destination, and searched via the REST
+ * events API. There is no SQL-shaped query surface, no row-level
+ * UPDATE/DELETE, and no identifier escaping, so Papertrail does not fit the
+ * SQL `Dialect` interface (`src/dialects/dialect.ts`). This class implements
+ * the minimal `NoSqlStore` marker interface (`src/nosql/store.ts`) and
+ * exposes Papertrail's ingest/search API.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Papertrail has no single canonical npm client; it is an HTTP/JSON API
+ * (`X-Papertrail-Token` auth). This store talks to it with the global
+ * `fetch` (so `library` is `'fetch'`). For tests (and custom transports) an
+ * alternative HTTP client can be injected via `PapertrailStoreOptions.client`.
+ *
+ * Search targets the REST API (`apiURL`); ingest targets the configured HTTP
+ * log destination (`ingestURL`). The internal client resolves absolute URLs
+ * verbatim, so `push()` posts to the full ingest URL while search/metadata
+ * methods use relative API paths.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(lines)`     -> `POST <ingestURL>`          (HTTP/syslog ingest)
+ * - `query(q, opts?)` -> `GET  /api/v1/events/search` (search events)
+ * - `labels()`        -> `GET  /api/v1/groups`        (log groups)
+ * - `streams()`       -> `GET  /api/v1/systems`       (systems/senders)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PapertrailStore = exports.DEFAULT_PAPERTRAIL_API_URL = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Papertrail REST API base URL. */
+exports.DEFAULT_PAPERTRAIL_API_URL = 'https://papertrailapp.com';
+/** Build a `fetch`-backed client for the given base URL. */
+function createFetchClient(baseURL, headers) {
+    const buildUrl = (path, params) => {
+        // Absolute URLs (the ingest URL) override the base entirely.
+        const url = new URL(path, baseURL.endsWith('/') ? baseURL : `${baseURL}/`);
+        for (const [key, value] of Object.entries(params ?? {})) {
+            if (value === undefined)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    url.searchParams.append(key, item);
+            }
+            else {
+                url.searchParams.set(key, value);
+            }
+        }
+        return url.toString();
+    };
+    return {
+        async get(path, params) {
+            const res = await fetch(buildUrl(path, params), {
+                method: 'GET',
+                headers: { Accept: 'application/json', ...(headers ?? {}) },
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return res.json();
+        },
+        async post(path, body, contentType) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                body,
+                headers: { ...(headers ?? {}), ...(contentType ? { 'Content-Type': contentType } : {}) },
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            const text = await res.text();
+            if (!text)
+                return undefined;
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        },
+    };
+}
+/**
+ * `PapertrailStore` wraps Papertrail's HTTP log-destination ingest and its
+ * REST events-search API (plus group/system metadata) behind the
+ * `NoSqlStore` lifecycle.
+ */
+class PapertrailStore {
+    constructor(options = {}) {
+        this.name = 'papertrail';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.apiURL = options.apiURL ?? exports.DEFAULT_PAPERTRAIL_API_URL;
+        this.ingestURL = options.ingestURL;
+        this.injectedClient = options.client;
+        this.headers = {
+            ...(options.headers ?? {}),
+            ...(options.token ? { 'X-Papertrail-Token': options.token } : {}),
+        };
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client)
+            return;
+        this.client = this.injectedClient ?? createFetchClient(this.apiURL, this.headers);
+        this.connected = true;
+    }
+    async disconnect() {
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to Papertrail', {
+                database: 'papertrail',
+                host: this.apiURL,
+            });
+        }
+        return this.client;
+    }
+    async doGet(path, params, action) {
+        const client = this.requireClient();
+        try {
+            return await client.get(path, params);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, {
+                message: `Papertrail ${action ?? 'request'} failed: ${parent.message}`,
+            });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Ingest (HTTP log destination)
+    // ---------------------------------------------------------------------
+    /**
+     * Ingests raw log lines by POSTing them (newline-delimited) to the
+     * configured HTTP log-destination `ingestURL`. Accepts a single string or
+     * an array of lines (joined with newlines).
+     */
+    async push(lines) {
+        if (!this.ingestURL) {
+            throw new errors_1.DatabaseError('Papertrail push requires an ingestURL to be configured');
+        }
+        const client = this.requireClient();
+        const body = Array.isArray(lines) ? lines.join('\n') : lines;
+        try {
+            return await client.post(this.ingestURL, body, 'text/plain');
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Papertrail push failed: ${parent.message}` });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Search
+    // ---------------------------------------------------------------------
+    /**
+     * Searches log events via `GET /api/v1/events/search`. Returns the parsed
+     * response (`{ events, min_id, max_id, reached_beginning, ... }`).
+     */
+    async query(q, options = {}) {
+        return this.doGet('/api/v1/events/search.json', {
+            q,
+            system_id: options.systemId === undefined ? undefined : String(options.systemId),
+            group_id: options.groupId === undefined ? undefined : String(options.groupId),
+            min_id: options.minId,
+            max_id: options.maxId,
+            min_time: options.minTime === undefined ? undefined : String(options.minTime),
+            max_time: options.maxTime === undefined ? undefined : String(options.maxTime),
+            limit: options.limit === undefined ? undefined : String(options.limit),
+        }, 'query');
+    }
+    // ---------------------------------------------------------------------
+    // Metadata
+    // ---------------------------------------------------------------------
+    /** Lists the configured log groups via `GET /api/v1/groups`. */
+    async labels() {
+        return this.doGet('/api/v1/groups.json', undefined, 'labels');
+    }
+    /** Lists the configured systems (log senders) via `GET /api/v1/systems`. */
+    async streams() {
+        return this.doGet('/api/v1/systems.json', undefined, 'streams');
+    }
+}
+exports.PapertrailStore = PapertrailStore;
+exports.default = PapertrailStore;