ts-prorm-orm 1.1.0

package/dist/nosql/gearman/index.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Gearman job-server store.
+ *
+ * Gearman is a generic application framework for farming out work: a *client*
+ * submits a job for a named function, the Gearman *job server* routes it to a
+ * *worker* that has registered a handler for that function, and the result
+ * flows back. 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 Gearman's real submit/register operations instead.
+ *
+ * Uses the `gearman` 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 client can be
+ * injected via `GearmanStoreOptions.client`, in which case `connect()` adopts
+ * it and skips the `require` entirely (used by the unit tests to inject a
+ * mock).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GearmanStore = 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 Gearman: ${parent.message}`;
+    return new errors_1.ConnectionError(message, { parent, database: 'gearman' });
+}
+function wrapDatabaseError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `Gearman ${action} failed: ${parent.message}` });
+}
+/**
+ * `GearmanStore` wraps a single `gearman` client and exposes the common queue
+ * surface over Gearman functions: `enqueue()` submits a job, `process()`
+ * registers a worker handler, and job status/removal/stats route to the
+ * driver's corresponding calls.
+ */
+class GearmanStore {
+    constructor(options = {}) {
+        this.name = 'gearman';
+        this.library = 'gearman';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            if (this.options.client != null) {
+                this.client = this.options.client;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const gearman = require('gearman');
+                const host = this.options.host || '127.0.0.1';
+                const port = this.options.port || 4730;
+                this.client =
+                    typeof gearman.createClient === 'function'
+                        ? gearman.createClient(port, host)
+                        : new gearman.Client(port, host);
+                if (typeof this.client.connect === 'function') {
+                    await this.client.connect();
+                }
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            throw wrapConnectionError(err);
+        }
+    }
+    async disconnect() {
+        try {
+            if (this.client) {
+                if (typeof this.client.close === 'function')
+                    this.client.close();
+                else if (typeof this.client.disconnect === 'function')
+                    this.client.disconnect();
+            }
+        }
+        catch {
+            // Ignore teardown errors.
+        }
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `gearman` client for operations not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to Gearman', { database: 'gearman' });
+        }
+        return this.client;
+    }
+    async exec(fn, action) {
+        const client = this.requireClient();
+        try {
+            return await fn(client);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, action);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Queue operations
+    // ---------------------------------------------------------------------
+    /**
+     * Submit a job for the named function (`queue`). The payload is
+     * JSON-serialized (strings pass through). Returns the job handle/id the
+     * server assigns (`job.handle` if the driver returns a job object).
+     */
+    async enqueue(queue, jobData, opts = {}) {
+        return this.exec(async (client) => {
+            const payload = typeof jobData === 'string' ? jobData : JSON.stringify(jobData);
+            const job = await client.submitJob(queue, payload, opts);
+            if (job == null)
+                return '';
+            return typeof job === 'string' ? job : job.handle ?? job.id ?? '';
+        }, 'enqueue');
+    }
+    /**
+     * Register a worker handler for the named function (`queue`). The driver
+     * invokes `handler(job)` for each dispatched task. Falls back to
+     * `addFunction()` when the driver has no `registerWorker()`.
+     */
+    async process(queue, handler) {
+        return this.exec((client) => {
+            if (typeof client.registerWorker === 'function') {
+                return client.registerWorker(queue, handler);
+            }
+            return client.addFunction(queue, handler);
+        }, 'process');
+    }
+    /** Query the status of a submitted job by its handle/id. */
+    async getJob(_queue, id) {
+        return this.exec((client) => client.getJobStatus(id), 'getJob');
+    }
+    /** Cancel/forget a submitted job by its handle/id. */
+    async remove(_queue, id) {
+        return this.exec((client) => client.removeJob(id), 'remove');
+    }
+    /** Return job-server status (registered functions, queued/running counts). */
+    async stats(_queue) {
+        return this.exec((client) => client.getStatus(), 'stats');
+    }
+}
+exports.GearmanStore = GearmanStore;
+exports.default = GearmanStore;

package/dist/nosql/geode/index.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Apache Geode store implementation.
+ *
+ * Apache Geode (the engine behind Pivotal/VMware GemFire) is a distributed
+ * in-memory data grid. Data lives in named *regions* (its distributed maps).
+ * There is no SQL-shaped `query(sql)` surface for key/value access, so this
+ * class implements the minimal `NoSqlStore` marker interface and exposes
+ * Geode's region operations (getMap/put/get/remove/keys/size) as a typed,
+ * promise-based API.
+ *
+ * ## Transport: the Geode Developer REST API over `fetch`
+ *
+ * Geode has no canonical Node.js driver; it ships a language-neutral
+ * "Developer REST API". This store talks to it with the global `fetch`
+ * (exactly like `PrometheusStore`), so `library` is `'fetch'`. For tests
+ * (and callers who want their own transport) an alternative client can be
+ * injected via `GeodeStoreOptions.client`; when omitted a tiny internal
+ * `fetch` client is built at connect time.
+ *
+ * Endpoints wrapped (all under `/geode/v1`):
+ * - `mapPut`    -> `PUT    /geode/v1/<region>/<key>`
+ * - `mapGet`    -> `GET    /geode/v1/<region>/<key>`
+ * - `mapRemove` -> `DELETE /geode/v1/<region>/<key>`
+ * - `mapKeys`   -> `GET    /geode/v1/<region>/keys`
+ * - `mapSize`   -> derived from `mapKeys` (the Developer REST API exposes no
+ *                  direct size endpoint)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeodeStore = exports.DEFAULT_GEODE_BASE_URL = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Geode Developer REST API base URL. */
+exports.DEFAULT_GEODE_BASE_URL = 'http://localhost:8080';
+/** Build a `fetch`-backed REST client for the given base URL. */
+function createFetchClient(baseURL, headers) {
+    const base = baseURL.endsWith('/') ? baseURL : `${baseURL}/`;
+    const buildUrl = (path) => new URL(path.startsWith('/') ? path.slice(1) : path, base).toString();
+    const parse = async (res) => {
+        const text = await res.text();
+        if (!text)
+            return null;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    };
+    return {
+        async get(path) {
+            const res = await fetch(buildUrl(path), { method: 'GET', headers });
+            if (res.status === 404)
+                return null;
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return parse(res);
+        },
+        async put(path, body, contentType = 'application/json') {
+            const res = await fetch(buildUrl(path), {
+                method: 'PUT',
+                body,
+                headers: { ...(headers ?? {}), 'Content-Type': contentType },
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return parse(res);
+        },
+        async delete(path) {
+            const res = await fetch(buildUrl(path), { method: 'DELETE', headers });
+            if (res.status === 404)
+                return null;
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return parse(res);
+        },
+    };
+}
+const enc = encodeURIComponent;
+/**
+ * `GeodeStore` wraps Geode's Developer REST API behind the `NoSqlStore`
+ * lifecycle and exposes named-region key/value operations.
+ */
+class GeodeStore {
+    constructor(options = {}) {
+        this.name = 'geode';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        /** Cached region handles, keyed by name so `getMap` is idempotent. */
+        this.regions = new Map();
+        this.baseURL = options.baseURL ?? exports.DEFAULT_GEODE_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.regions.clear();
+        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 Geode', {
+                database: 'geode',
+                host: this.baseURL,
+            });
+        }
+        return this.client;
+    }
+    wrap(err, action) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        return errors_1.DatabaseError.from(parent, { message: `Geode ${action} failed: ${parent.message}` });
+    }
+    // ---------------------------------------------------------------------
+    // Distributed region operations
+    // ---------------------------------------------------------------------
+    /** Resolve (and cache) a named-region handle. */
+    async getMap(name) {
+        this.requireClient();
+        let region = this.regions.get(name);
+        if (!region) {
+            region = { name };
+            this.regions.set(name, region);
+        }
+        return region;
+    }
+    /** Store `value` under `key` in `map` (`PUT /geode/v1/<region>/<key>`). */
+    async mapPut(map, key, value) {
+        const client = this.requireClient();
+        try {
+            await client.put(`/geode/v1/${enc(map.name)}/${enc(key)}`, JSON.stringify(value));
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapPut');
+        }
+    }
+    /** Read `key` from `map` (`GET /geode/v1/<region>/<key>`); `null` if absent. */
+    async mapGet(map, key) {
+        const client = this.requireClient();
+        try {
+            return await client.get(`/geode/v1/${enc(map.name)}/${enc(key)}`);
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapGet');
+        }
+    }
+    /** Remove `key` from `map` (`DELETE /geode/v1/<region>/<key>`). */
+    async mapRemove(map, key) {
+        const client = this.requireClient();
+        try {
+            return await client.delete(`/geode/v1/${enc(map.name)}/${enc(key)}`);
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapRemove');
+        }
+    }
+    /** List all keys in `map` (`GET /geode/v1/<region>/keys`). */
+    async mapKeys(map) {
+        const client = this.requireClient();
+        try {
+            const body = await client.get(`/geode/v1/${enc(map.name)}/keys`);
+            // Geode replies `{ "keys": [...] }`; tolerate a bare array too.
+            if (Array.isArray(body))
+                return body;
+            if (body && Array.isArray(body.keys))
+                return body.keys;
+            return [];
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapKeys');
+        }
+    }
+    /** Number of entries in `map` (derived from `mapKeys`). */
+    async mapSize(map) {
+        return (await this.mapKeys(map)).length;
+    }
+}
+exports.GeodeStore = GeodeStore;
+exports.default = GeodeStore;

package/dist/nosql/graphdb/index.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Ontotext GraphDB store implementation.
+ *
+ * GraphDB is an RDF triplestore that speaks the SPARQL 1.1 Protocol over HTTP.
+ * A repository exposes a query endpoint (`/repositories/<repo>`) and an update
+ * endpoint (`/repositories/<repo>/statements`). There is no SQL-shaped surface
+ * (no rows, no DDL, no identifier escaping), so it implements the minimal
+ * `NoSqlStore` marker interface (`src/nosql/store.ts`) rather than the SQL
+ * `Dialect` interface.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * GraphDB has no dedicated npm client; it is just a SPARQL/HTTP endpoint. This
+ * store talks to the server with the global `fetch`. For tests (and for
+ * callers who want their own transport) an alternative client can be injected
+ * via `GraphdbStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `endpoint` is built at connect time.
+ *
+ * ## Surface
+ *
+ * - `query(sparql)`  -> POST to `/repositories/<repo>`, returns bindings
+ * - `update(sparql)` -> POST to `/repositories/<repo>/statements`
+ * - `ask(sparql)`    -> POST an ASK query, returns the boolean
+ * - `add(triples)`   -> `INSERT DATA { ... }` update
+ * - `drop(graph?)`   -> `DROP GRAPH <g>` / `DROP ALL` update
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphdbStore = exports.DEFAULT_GRAPHDB_REPOSITORY = exports.DEFAULT_GRAPHDB_ENDPOINT = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default GraphDB base URL. */
+exports.DEFAULT_GRAPHDB_ENDPOINT = 'http://localhost:7200';
+/** Default repository id. */
+exports.DEFAULT_GRAPHDB_REPOSITORY = 'repo';
+/** Build a `fetch`-backed SPARQL client for the given endpoint. */
+function createFetchClient(endpoint, headers) {
+    const base = endpoint.endsWith('/') ? endpoint : `${endpoint}/`;
+    const buildUrl = (path) => new URL(path.replace(/^\//, ''), base).toString();
+    return {
+        async query(path, sparql) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/sparql-query',
+                    Accept: 'application/sparql-results+json',
+                    ...(headers ?? {}),
+                },
+                body: sparql,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return res.json();
+        },
+        async update(path, sparql) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/sparql-update', ...(headers ?? {}) },
+                body: sparql,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            const text = await res.text();
+            return text || undefined;
+        },
+    };
+}
+/**
+ * `GraphdbStore` wraps a GraphDB repository's SPARQL query/update endpoints
+ * behind the `NoSqlStore` lifecycle.
+ */
+class GraphdbStore {
+    constructor(options = {}) {
+        this.name = 'graphdb';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.endpoint = options.endpoint ?? exports.DEFAULT_GRAPHDB_ENDPOINT;
+        this.repository = options.repository ?? exports.DEFAULT_GRAPHDB_REPOSITORY;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    /** SPARQL query endpoint path for the configured repository. */
+    get queryPath() {
+        return `/repositories/${this.repository}`;
+    }
+    /** SPARQL update endpoint path for the configured repository. */
+    get updatePath() {
+        return `/repositories/${this.repository}/statements`;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client)
+            return;
+        this.client = this.injectedClient ?? createFetchClient(this.endpoint, 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) SPARQL HTTP client. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to GraphDB', {
+                database: 'graphdb',
+                host: this.endpoint,
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // SPARQL surface
+    // ---------------------------------------------------------------------
+    /** Runs a SPARQL SELECT/CONSTRUCT query; returns the result bindings. */
+    async query(sparql) {
+        const client = this.requireClient();
+        try {
+            const body = await client.query(this.queryPath, sparql);
+            return body?.results?.bindings ?? [];
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `GraphDB query failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Runs a SPARQL ASK query; returns the boolean answer. */
+    async ask(sparql) {
+        const client = this.requireClient();
+        try {
+            const body = await client.query(this.queryPath, sparql);
+            return Boolean(body?.boolean);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `GraphDB ask failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Runs a SPARQL UPDATE (INSERT/DELETE/DROP/...). */
+    async update(sparql) {
+        const client = this.requireClient();
+        try {
+            return await client.update(this.updatePath, sparql);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `GraphDB update failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Inserts triples via `INSERT DATA { ... }`. Accepts a triple string or array. */
+    async add(triples, graph) {
+        const body = Array.isArray(triples) ? triples.join('\n') : triples;
+        const inner = graph ? `GRAPH <${graph}> { ${body} }` : body;
+        return this.update(`INSERT DATA { ${inner} }`);
+    }
+    /** Drops a named graph, or all graphs when no graph is given. */
+    async drop(graph) {
+        return this.update(graph ? `DROP GRAPH <${graph}>` : 'DROP ALL');
+    }
+}
+exports.GraphdbStore = GraphdbStore;