ts-prorm-orm 1.1.0

package/dist/nosql/graylog/index.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Graylog store implementation.
+ *
+ * Graylog is a centralized log-management platform. Logs are ingested in the
+ * GELF (Graylog Extended Log Format) over an HTTP input, and searched via
+ * the REST universal search API. There is no SQL-shaped query surface, no
+ * row-level UPDATE/DELETE, and no identifier escaping, so Graylog 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 Graylog's ingest/search API.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Graylog has no single canonical npm client; it is an HTTP/JSON API. 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 `GraylogStoreOptions.client`.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(host, entries)` -> `POST /gelf`  (GELF ingest, one message per entry)
+ * - `query(q, opts?)`     -> `GET  /api/search/universal/relative`  (search)
+ * - `labels()`            -> `GET  /api/system/fields`  (message field names)
+ * - `streams()`           -> `GET  /api/streams`  (configured streams)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraylogStore = exports.DEFAULT_GRAYLOG_BASE_URL = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Graylog HTTP base URL (GELF HTTP input on 12201, REST on 9000). */
+exports.DEFAULT_GRAYLOG_BASE_URL = 'http://localhost:9000';
+/** Build a `fetch`-backed client for the given base URL. */
+function createFetchClient(baseURL, headers) {
+    const buildUrl = (path, params) => {
+        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;
+            }
+        },
+    };
+}
+/**
+ * `GraylogStore` wraps Graylog's GELF HTTP ingest input and its REST
+ * universal-search / metadata API behind the `NoSqlStore` lifecycle.
+ */
+class GraylogStore {
+    constructor(options = {}) {
+        this.name = 'graylog';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.baseURL = options.baseURL ?? exports.DEFAULT_GRAYLOG_BASE_URL;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client)
+            return;
+        this.client = this.injectedClient ?? createFetchClient(this.baseURL, 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 Graylog', {
+                database: 'graylog',
+                host: this.baseURL,
+            });
+        }
+        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: `Graylog ${action ?? 'request'} failed: ${parent.message}`,
+            });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Ingest (GELF HTTP)
+    // ---------------------------------------------------------------------
+    /**
+     * Ingests one or more log entries as GELF messages via `POST /gelf`. Each
+     * entry is completed into a GELF `1.1` message with the shared `host`, and
+     * messages are newline-delimited (the GELF HTTP input accepts one JSON
+     * message per line).
+     */
+    async push(host, entries) {
+        const client = this.requireClient();
+        const body = entries
+            .map((entry) => JSON.stringify({ version: '1.1', host, ...entry }))
+            .join('\n');
+        try {
+            return await client.post('/gelf', body, 'application/json');
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Graylog push failed: ${parent.message}` });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Search
+    // ---------------------------------------------------------------------
+    /**
+     * Runs a relative universal search via
+     * `GET /api/search/universal/relative`. Returns the parsed response
+     * (`{ messages, total_results, fields, ... }`).
+     */
+    async query(q, options = {}) {
+        return this.doGet('/api/search/universal/relative', {
+            query: q,
+            range: String(options.range ?? 300),
+            limit: options.limit === undefined ? undefined : String(options.limit),
+            offset: options.offset === undefined ? undefined : String(options.offset),
+            sort: options.sort,
+            filter: options.filter,
+        }, 'query');
+    }
+    // ---------------------------------------------------------------------
+    // Metadata
+    // ---------------------------------------------------------------------
+    /** Lists the known message field names via `GET /api/system/fields`. */
+    async labels() {
+        return this.doGet('/api/system/fields', undefined, 'labels');
+    }
+    /** Lists the configured streams via `GET /api/streams`. */
+    async streams() {
+        return this.doGet('/api/streams', undefined, 'streams');
+    }
+}
+exports.GraylogStore = GraylogStore;
+exports.default = GraylogStore;

package/dist/nosql/gridgain/index.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * GridGain store implementation.
+ *
+ * GridGain is the commercial in-memory computing platform built on (and
+ * wire-compatible with) Apache Ignite: it speaks the same thin-client
+ * protocol and exposes the same distributed key/value caches. Consequently
+ * this store uses the very same `apache-ignite-client` Node.js thin-client
+ * driver as `IgniteStore`, differing only in `name` ('gridgain') and the
+ * error/message labels. Like Ignite it targets the distributed-cache
+ * (key/value grid) surface rather than SQL, so it implements the minimal
+ * `NoSqlStore` marker interface and exposes cache operations
+ * (getCache/put/get/removeKey/getKeys/getSize) as a typed, promise-based API.
+ *
+ * The driver is loaded lazily inside `connect()` (or supplied pre-built via
+ * the `client` option) so importing this module never requires
+ * `apache-ignite-client` to be installed unless a GridGain store is actually
+ * connected. Tests inject a mock client this way.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridGainStore = 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 GridGain: ${parent.message}`;
+    return new errors_1.ConnectionError(message, { parent, database: 'gridgain' });
+}
+function wrapDatabaseError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `GridGain ${action} failed: ${parent.message}` });
+}
+/**
+ * `GridGainStore` wraps an `apache-ignite-client` client (GridGain is
+ * Ignite-based and shares the thin-client protocol) and exposes its
+ * distributed-cache operations as a typed, promise-based API.
+ */
+class GridGainStore {
+    constructor(options = {}) {
+        this.name = 'gridgain';
+        this.library = 'apache-ignite-client';
+        this.client = null;
+        this.connected = false;
+        /** Resolved `CacheClient` handles, cached by name so `getMap` is idempotent. */
+        this.caches = new Map();
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            if (this.options.client) {
+                this.client = this.options.client;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mod = require('apache-ignite-client');
+                const IgniteClient = mod.IgniteClient ?? mod;
+                const IgniteClientConfiguration = mod.IgniteClientConfiguration;
+                const client = new IgniteClient();
+                const endpoints = this.options.endpoints ?? ['127.0.0.1:10800'];
+                const cfg = new IgniteClientConfiguration(...endpoints);
+                await client.connect(cfg);
+                this.client = client;
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            throw wrapConnectionError(err);
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            try {
+                await this.client.disconnect();
+            }
+            catch {
+                // best-effort disconnect
+            }
+            this.client = null;
+        }
+        this.caches.clear();
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `apache-ignite-client` client for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to GridGain', { database: 'gridgain' });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // Distributed cache operations
+    // ---------------------------------------------------------------------
+    /** Resolve (and cache) a distributed cache handle by name. */
+    async getMap(name) {
+        const cached = this.caches.get(name);
+        if (cached) {
+            return cached;
+        }
+        const client = this.requireClient();
+        try {
+            const cache = await client.getCache(name);
+            this.caches.set(name, cache);
+            return cache;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'getCache');
+        }
+    }
+    /** Put `value` under `key` in `map` (a GridGain cache handle). */
+    async mapPut(map, key, value) {
+        try {
+            return await map.put(key, value);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'cache put');
+        }
+    }
+    /** Get the value stored under `key` in `map` (or null if absent). */
+    async mapGet(map, key) {
+        try {
+            return await map.get(key);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'cache get');
+        }
+    }
+    /** Remove `key` from `map`. Returns GridGain's boolean success flag. */
+    async mapRemove(map, key) {
+        try {
+            return await map.removeKey(key);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'cache removeKey');
+        }
+    }
+    /** Return all keys currently in `map` as an array. */
+    async mapKeys(map) {
+        try {
+            return await map.getKeys();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'cache getKeys');
+        }
+    }
+    /** Return the number of entries in `map`. */
+    async mapSize(map) {
+        try {
+            return await map.getSize();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'cache getSize');
+        }
+    }
+}
+exports.GridGainStore = GridGainStore;
+exports.default = GridGainStore;

package/dist/nosql/hazelcast/index.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Hazelcast store implementation.
+ *
+ * Hazelcast is a distributed in-memory data grid (IMDG). Its central data
+ * structure is the distributed `IMap` - a partitioned, replicated key/value
+ * map spread across cluster members. It has no SQL-shaped `query(sql)`
+ * surface, so this class implements the minimal `NoSqlStore` marker
+ * interface and exposes Hazelcast's distributed-map operations
+ * (getMap/put/get/remove/keySet/size) as a typed, promise-based API.
+ *
+ * Uses the `hazelcast-client` driver. The driver is loaded lazily inside
+ * `connect()` (or supplied pre-built via the `client` option) so importing
+ * this module never requires `hazelcast-client` to be installed unless a
+ * Hazelcast store is actually connected. Tests inject a mock client this way.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HazelcastStore = 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 Hazelcast: ${parent.message}`;
+    return new errors_1.ConnectionError(message, { parent, database: 'hazelcast' });
+}
+function wrapDatabaseError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `Hazelcast ${action} failed: ${parent.message}` });
+}
+/**
+ * `HazelcastStore` wraps a `hazelcast-client` `Client` and exposes its
+ * distributed `IMap` operations as a typed, promise-based API.
+ */
+class HazelcastStore {
+    constructor(options = {}) {
+        this.name = 'hazelcast';
+        this.library = 'hazelcast-client';
+        this.client = null;
+        this.connected = false;
+        /** Resolved `IMap` handles, cached by map name so `getMap` is idempotent. */
+        this.maps = new Map();
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            if (this.options.client) {
+                this.client = this.options.client;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const hazelcast = require('hazelcast-client');
+                const Client = hazelcast.Client ?? hazelcast;
+                this.client = (await Client.newHazelcastClient(this.options.config));
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            throw wrapConnectionError(err);
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            try {
+                await this.client.shutdown();
+            }
+            catch {
+                // best-effort shutdown
+            }
+            this.client = null;
+        }
+        this.maps.clear();
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `hazelcast-client` client for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to Hazelcast', { database: 'hazelcast' });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // Distributed map (IMap) operations
+    // ---------------------------------------------------------------------
+    /** Resolve (and cache) a distributed `IMap` handle by name. */
+    async getMap(name) {
+        const cached = this.maps.get(name);
+        if (cached) {
+            return cached;
+        }
+        const client = this.requireClient();
+        try {
+            const map = await client.getMap(name);
+            this.maps.set(name, map);
+            return map;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'getMap');
+        }
+    }
+    /** Put `value` under `key` in `map`, returning the previous value (or null). */
+    async mapPut(map, key, value) {
+        try {
+            return await map.put(key, value);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'map put');
+        }
+    }
+    /** Get the value stored under `key` in `map` (or null if absent). */
+    async mapGet(map, key) {
+        try {
+            return await map.get(key);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'map get');
+        }
+    }
+    /** Remove `key` from `map`, returning the removed value (or null). */
+    async mapRemove(map, key) {
+        try {
+            return await map.remove(key);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'map remove');
+        }
+    }
+    /** Return all keys currently in `map` as an array. */
+    async mapKeys(map) {
+        try {
+            return await map.keySet();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'map keys');
+        }
+    }
+    /** Return the number of entries in `map`. */
+    async mapSize(map) {
+        try {
+            return await map.size();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'map size');
+        }
+    }
+}
+exports.HazelcastStore = HazelcastStore;
+exports.default = HazelcastStore;