ts-prorm-orm 1.1.0

package/dist/nosql/leveldb/index.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LevelDBStore = void 0;
+/**
+ * LevelDB store.
+ *
+ * LevelDB is an embedded, in-process ordered key-value store (no server),
+ * accessed here through the `level` package (an `abstract-level`
+ * implementation). A store is opened against a filesystem path and exposes
+ * ordered KV primitives — `put`/`get`/`del`, atomic `batch` writes, and
+ * ordered iteration via `db.iterator()`. It has no query language and no
+ * SQL-shaped surface, so it does not fit the `Dialect` interface used by the
+ * SQL dialects in this repo. Instead it implements the minimal `NoSqlStore`
+ * marker interface (`src/nosql/store.ts`) and exposes LevelDB's real KV
+ * surface directly.
+ *
+ * Built on the `level` npm driver, loaded lazily inside `connect()` (via
+ * `require`) so importing this module never forces the driver to be installed;
+ * tests inject a pre-built mock `client` instead and never reach the `require`.
+ */
+const errors_1 = require("../../errors");
+/**
+ * `LevelDBStore` wraps a `level` client and exposes its embedded KV surface:
+ * `put`/`get`/`del` for single keys, `batch` for atomic multi-key writes, and
+ * `list` for ordered key iteration (optionally by prefix).
+ */
+class LevelDBStore {
+    constructor(options = {}) {
+        this.name = 'leveldb';
+        this.library = 'level';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+        this.path = options.path ?? './data/leveldb';
+    }
+    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('level');
+                const Level = mod.Level ?? mod;
+                this.client = new Level(this.path);
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw new errors_1.ConnectionError(`Unable to open LevelDB: ${parent.message}`, {
+                parent,
+                database: 'leveldb',
+            });
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch {
+                // best-effort close
+            }
+            this.client = null;
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `level` client for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('LevelDB client is not connected. Call connect() first.', {
+                database: 'leveldb',
+            });
+        }
+        return this.client;
+    }
+    wrapError(action, err) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        return errors_1.DatabaseError.from(parent, { message: `LevelDB ${action} failed: ${parent.message}` });
+    }
+    /** Writes (or overwrites) the value at `key`. */
+    async put(key, value) {
+        const client = this.requireClient();
+        try {
+            await client.put(key, value);
+        }
+        catch (err) {
+            throw this.wrapError('put', err);
+        }
+    }
+    /** Reads the value at `key`. */
+    async get(key) {
+        const client = this.requireClient();
+        try {
+            return await client.get(key);
+        }
+        catch (err) {
+            throw this.wrapError('get', err);
+        }
+    }
+    /** Deletes the value at `key`. */
+    async del(key) {
+        const client = this.requireClient();
+        try {
+            await client.del(key);
+        }
+        catch (err) {
+            throw this.wrapError('del', err);
+        }
+    }
+    /** Applies a list of `put`/`del` operations as a single atomic batch. */
+    async batch(ops) {
+        const client = this.requireClient();
+        try {
+            await client.batch(ops);
+        }
+        catch (err) {
+            throw this.wrapError('batch', err);
+        }
+    }
+    /**
+     * Lists keys in order. With `prefix`, restricts to keys `>= prefix` and
+     * `< prefix + '\xff'` (a standard prefix-scan range for byte-ordered keys).
+     */
+    async list(prefix) {
+        const client = this.requireClient();
+        try {
+            const range = prefix !== undefined ? { gte: prefix, lt: `${prefix}\xff` } : {};
+            const keys = [];
+            for await (const [key] of client.iterator(range)) {
+                keys.push(String(key));
+            }
+            return keys;
+        }
+        catch (err) {
+            throw this.wrapError('list', err);
+        }
+    }
+}
+exports.LevelDBStore = LevelDBStore;
+exports.default = LevelDBStore;

package/dist/nosql/lmdb/index.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmdbStore = void 0;
+/**
+ * LMDB store.
+ *
+ * LMDB (Lightning Memory-Mapped Database) is an embedded, in-process,
+ * memory-mapped ordered key-value store (no server). A database is opened
+ * against a filesystem path and exposes ordered KV primitives — `put`/`get`,
+ * `remove` for deletes, and ordered range scans via `getRange`. It has no
+ * query language and no SQL-shaped surface, so it does not fit the `Dialect`
+ * interface used by the SQL dialects in this repo. Instead it implements the
+ * minimal `NoSqlStore` marker interface (`src/nosql/store.ts`) and exposes
+ * LMDB's real KV surface directly.
+ *
+ * Built on the `lmdb` npm driver, loaded lazily inside `connect()` (via
+ * `require`) so importing this module never forces the driver to be installed;
+ * tests inject a pre-built mock `client` instead and never reach the `require`.
+ */
+const errors_1 = require("../../errors");
+/**
+ * `LmdbStore` wraps an `lmdb` database and exposes its embedded KV surface:
+ * `put`/`get`/`del` for single keys, `batch` for multi-key writes, and `list`
+ * for ordered key range scans (optionally by prefix).
+ */
+class LmdbStore {
+    constructor(options = {}) {
+        this.name = 'lmdb';
+        this.library = 'lmdb';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+        this.path = options.path ?? './data/lmdb';
+    }
+    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 lmdb = require('lmdb');
+                this.client = lmdb.open({ path: this.path, ...this.options.config });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw new errors_1.ConnectionError(`Unable to open LMDB: ${parent.message}`, {
+                parent,
+                database: 'lmdb',
+            });
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch {
+                // best-effort close
+            }
+            this.client = null;
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `lmdb` database for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('LMDB database is not connected. Call connect() first.', {
+                database: 'lmdb',
+            });
+        }
+        return this.client;
+    }
+    wrapError(action, err) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        return errors_1.DatabaseError.from(parent, { message: `LMDB ${action} failed: ${parent.message}` });
+    }
+    /** Writes (or overwrites) the value at `key`. */
+    async put(key, value) {
+        const client = this.requireClient();
+        try {
+            await client.put(key, value);
+        }
+        catch (err) {
+            throw this.wrapError('put', err);
+        }
+    }
+    /** Reads the value at `key` (LMDB reads are synchronous; the result is returned directly). */
+    async get(key) {
+        const client = this.requireClient();
+        try {
+            return client.get(key);
+        }
+        catch (err) {
+            throw this.wrapError('get', err);
+        }
+    }
+    /** Deletes the value at `key` (LMDB `remove`). */
+    async del(key) {
+        const client = this.requireClient();
+        try {
+            await client.remove(key);
+        }
+        catch (err) {
+            throw this.wrapError('del', err);
+        }
+    }
+    /** Applies a list of `put`/`del` operations. LMDB coalesces concurrent writes into one transaction. */
+    async batch(ops) {
+        const client = this.requireClient();
+        try {
+            const pending = [];
+            for (const op of ops) {
+                if (op.type === 'put') {
+                    pending.push(client.put(op.key, op.value));
+                }
+                else {
+                    pending.push(client.remove(op.key));
+                }
+            }
+            await Promise.all(pending);
+        }
+        catch (err) {
+            throw this.wrapError('batch', err);
+        }
+    }
+    /**
+     * Lists keys in order via `getRange`. With `prefix`, restricts to keys
+     * `>= prefix` and `< prefix + '\xff'` (a standard prefix-scan range).
+     */
+    async list(prefix) {
+        const client = this.requireClient();
+        try {
+            const range = prefix !== undefined ? { start: prefix, end: `${prefix}\xff` } : {};
+            const keys = [];
+            for (const { key } of client.getRange(range)) {
+                keys.push(String(key));
+            }
+            return keys;
+        }
+        catch (err) {
+            throw this.wrapError('list', err);
+        }
+    }
+}
+exports.LmdbStore = LmdbStore;
+exports.default = LmdbStore;

package/dist/nosql/loki/index.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * Grafana Loki store implementation.
+ *
+ * Loki is a horizontally-scalable, multi-tenant log aggregation system. It
+ * indexes only a small set of labels per log stream (not the log contents)
+ * and is queried with LogQL, a label-matcher + filter language modelled on
+ * PromQL. There is no SQL-shaped query surface, no row-level UPDATE/DELETE,
+ * and no identifier escaping, so Loki 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 Loki's
+ * HTTP push/query API directly.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Loki has no single canonical npm client; it is just an HTTP/JSON API.
+ * Rather than depend on any package, this store talks to the server with
+ * the global `fetch` (so `library` is `'fetch'`). For tests (and for callers
+ * who want their own transport), an alternative HTTP client can be injected
+ * via `LokiStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `baseURL` is built at connect time.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(labels, entries)` -> `POST /loki/api/v1/push`  (ingest log lines)
+ * - `query(logql, opts?)`   -> `GET  /loki/api/v1/query_range`  (search)
+ * - `labels()`              -> `GET  /loki/api/v1/labels`  (label names)
+ * - `streams(match?)`       -> `GET  /loki/api/v1/series`  (label sets)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiStore = exports.DEFAULT_LOKI_BASE_URL = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Grafana Loki HTTP API base URL. */
+exports.DEFAULT_LOKI_BASE_URL = 'http://localhost:3100';
+/** 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 });
+            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;
+            }
+        },
+    };
+}
+/**
+ * `LokiStore` wraps Grafana Loki's HTTP push/query API (log ingestion via
+ * the push endpoint, LogQL range search, and label/series metadata lookups)
+ * behind the `NoSqlStore` lifecycle.
+ */
+class LokiStore {
+    constructor(options = {}) {
+        this.name = 'loki';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.baseURL = options.baseURL ?? exports.DEFAULT_LOKI_BASE_URL;
+        this.injectedClient = options.client;
+        this.headers = {
+            ...(options.headers ?? {}),
+            ...(options.tenantID ? { 'X-Scope-OrgID': options.tenantID } : {}),
+        };
+    }
+    // ---------------------------------------------------------------------
+    // 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 Loki', {
+                database: 'loki',
+                host: this.baseURL,
+            });
+        }
+        return this.client;
+    }
+    async doGet(path, params, action) {
+        const client = this.requireClient();
+        try {
+            const body = await client.get(path, params);
+            return body?.data;
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, {
+                message: `Loki ${action ?? 'request'} failed: ${parent.message}`,
+            });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Ingest
+    // ---------------------------------------------------------------------
+    /**
+     * Pushes a batch of log entries for one stream (identified by its label
+     * set) via `POST /loki/api/v1/push`. Each entry is serialized as
+     * `[<ts-ns>, <line>]` (plus optional structured metadata) in Loki's
+     * push payload shape.
+     */
+    async push(labels, entries) {
+        const client = this.requireClient();
+        const values = entries.map((e) => e.metadata
+            ? [String(e.ts), e.line, e.metadata]
+            : [String(e.ts), e.line]);
+        const payload = { streams: [{ stream: labels, values }] };
+        try {
+            return await client.post('/loki/api/v1/push', JSON.stringify(payload), 'application/json');
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Loki push failed: ${parent.message}` });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Query
+    // ---------------------------------------------------------------------
+    /**
+     * Runs a LogQL query over a time window via `GET /loki/api/v1/query_range`.
+     * Returns the `data` payload (`{ resultType, result }`).
+     */
+    async query(logql, options = {}) {
+        return this.doGet('/loki/api/v1/query_range', {
+            query: logql,
+            start: options.start === undefined ? undefined : String(options.start),
+            end: options.end === undefined ? undefined : String(options.end),
+            limit: options.limit === undefined ? undefined : String(options.limit),
+            direction: options.direction,
+            step: options.step === undefined ? undefined : String(options.step),
+        }, 'query');
+    }
+    // ---------------------------------------------------------------------
+    // Metadata
+    // ---------------------------------------------------------------------
+    /** Lists the known label names via `GET /loki/api/v1/labels`. */
+    async labels() {
+        return this.doGet('/loki/api/v1/labels', undefined, 'labels');
+    }
+    /**
+     * Lists the label sets (streams) matching an optional selector via
+     * `GET /loki/api/v1/series`.
+     */
+    async streams(match) {
+        const matches = match === undefined ? undefined : Array.isArray(match) ? match : [match];
+        return this.doGet('/loki/api/v1/series', matches ? { 'match[]': matches } : undefined, 'series');
+    }
+    /** Lists the distinct values of a label via `GET /loki/api/v1/label/<name>/values`. */
+    async labelValues(label) {
+        return this.doGet(`/loki/api/v1/label/${encodeURIComponent(label)}/values`, undefined, 'labelValues');
+    }
+}
+exports.LokiStore = LokiStore;
+exports.default = LokiStore;