ts-prorm-orm 1.1.0

package/dist/nosql/doris/index.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Apache Doris store.
+ *
+ * Apache Doris is a real-time MPP analytical (OLAP) database. Like StarRocks
+ * (with which it shares ancestry), it speaks the **MySQL wire protocol**, so
+ * it is queried with the `mysql2` driver over a normal MySQL connection/pool.
+ * Doris is a columnar analytics engine rather than an OLTP store, which does
+ * not fit this ORM's SQL `Dialect` abstraction cleanly, so it is modelled as
+ * a `NoSqlStore` (`src/nosql/store.ts`) exposing a direct `query`/`ingest`
+ * surface.
+ *
+ * ## Driver: `mysql2` (MySQL-wire)
+ *
+ * The `mysql2` package is an optional peer dependency, lazily `require`d
+ * inside `connect()` so importing this module never forces it to be
+ * installed. Tests inject a pre-built mock connection via
+ * `DorisStoreOptions.client`, which skips the `require` entirely.
+ *
+ * ## Ingestion
+ *
+ * `ingest()` performs a batched `INSERT` over the MySQL wire. For
+ * high-throughput loading Doris also offers **Stream Load** (an HTTP
+ * `PUT /api/{db}/{table}/_stream_load` endpoint). Stream Load is a separate
+ * (optional) HTTP transport and is intentionally not wired here; use the
+ * `mysql2`-based `ingest()` for wire-level inserts, or POST to the Stream Load
+ * endpoint yourself for bulk pipelines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DorisStore = void 0;
+const errors_1 = require("../../errors");
+/**
+ * `DorisStore` wraps a `mysql2` connection to a Doris frontend and exposes
+ * `query(sql, params)` for reads/DDL and `ingest(table, rows)` for batched
+ * wire-level inserts.
+ */
+class DorisStore {
+    constructor(options = {}) {
+        this.name = 'doris';
+        this.library = 'mysql2';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // NoSqlStore lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            let client = this.options.client;
+            if (!client) {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mysql = require('mysql2/promise');
+                client = (await mysql.createConnection({
+                    host: this.options.host,
+                    port: this.options.port,
+                    user: this.options.user,
+                    password: this.options.password,
+                    database: this.options.database,
+                    ...this.options.connectionOptions,
+                }));
+            }
+            this.client = client;
+            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 connect to Doris: ${parent.message}`, {
+                parent,
+                database: 'doris',
+                host: this.options.host,
+            });
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            try {
+                await this.client.end?.();
+            }
+            finally {
+                this.client = null;
+                this.connected = false;
+            }
+        }
+        else {
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `mysql2` connection for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('Doris client is not connected. Call connect() first.', {
+                database: 'doris',
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // Query + ingest
+    // ---------------------------------------------------------------------
+    /**
+     * Execute a SQL statement over the MySQL wire with optional positional
+     * `params` and return the result rows (the first element of `mysql2`'s
+     * `[rows, fields]` tuple).
+     */
+    async query(sql, params) {
+        const client = this.requireClient();
+        try {
+            const [rows] = await client.query(sql, params);
+            return (rows ?? []);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, {
+                message: `Doris query failed: ${parent.message}`,
+                sql,
+            });
+        }
+    }
+    /**
+     * Batch-insert `rows` into `table` via a single parameterized
+     * `INSERT INTO table (cols) VALUES (...)` over the MySQL wire. Columns are
+     * taken from the first row. Returns the driver result (`OkPacket`).
+     *
+     * For high-throughput bulk loading, use Doris Stream Load (HTTP) instead —
+     * see the module header.
+     */
+    async ingest(table, rows) {
+        if (rows.length === 0) {
+            throw new errors_1.DatabaseError('ingest() requires at least one row', {
+                original: 'empty rows array',
+            });
+        }
+        const columns = Object.keys(rows[0]);
+        if (columns.length === 0) {
+            throw new errors_1.DatabaseError('ingest() requires at least one column', {
+                original: 'empty row object',
+            });
+        }
+        const values = rows.map((r) => columns.map((c) => r[c]));
+        const client = this.requireClient();
+        // mysql2 expands a single `?` bound to a nested array into a bulk VALUES list.
+        const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES ?`;
+        try {
+            const [result] = await client.query(sql, [values]);
+            return result;
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, {
+                message: `Doris ingest failed: ${parent.message}`,
+                sql,
+            });
+        }
+    }
+}
+exports.DorisStore = DorisStore;
+exports.default = DorisStore;

package/dist/nosql/druid/index.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Apache Druid store.
+ *
+ * Druid is a real-time OLAP / analytics datastore designed for sub-second
+ * queries over large event streams. It is not a relational database: it has
+ * no cross-datasource joins in the classic sense, no row-level UPDATE/DELETE,
+ * and ingestion happens by submitting *tasks* to an indexing service rather
+ * than by running `INSERT`. That model does not fit the SQL-shaped `Dialect`
+ * interface (`src/dialects/dialect.ts`), so this class implements the minimal
+ * `NoSqlStore` marker interface (`src/nosql/store.ts`) and talks to Druid's
+ * HTTP JSON API directly.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Druid has no single canonical npm client; it is just an HTTP/JSON API.
+ * Rather than depend on any package this store uses the global `fetch`. Tests
+ * (and callers wanting their own transport) can inject an alternative client
+ * via `DruidStoreOptions.client`; when omitted a tiny `fetch`-based client is
+ * built against `endpoint` at `connect()` time.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `query(sql, params?)`  -> `POST /druid/v2/sql`      (Druid SQL, returns rows)
+ * - `nativeQuery(spec)`    -> `POST /druid/v2`          (native JSON query)
+ * - `ingest(target, rows)` -> `POST /druid/indexer/v1/task` (inline index task)
+ * - `submitTask(spec)`     -> `POST /druid/indexer/v1/task` (arbitrary task spec)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DruidStore = exports.DEFAULT_DRUID_ENDPOINT = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Druid router/broker HTTP endpoint. */
+exports.DEFAULT_DRUID_ENDPOINT = 'http://localhost:8888';
+/** Build a `fetch`-backed client for the given endpoint. */
+function createFetchClient(endpoint, headers) {
+    const base = endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
+    return {
+        async post(path, body) {
+            const res = await fetch(`${base}${path}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...(headers ?? {}) },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            }
+            const text = await res.text();
+            return text ? JSON.parse(text) : undefined;
+        },
+    };
+}
+/**
+ * `DruidStore` wraps Druid's HTTP query + indexing API behind the
+ * `NoSqlStore` lifecycle: SQL and native queries for reads, task submission
+ * for ingestion.
+ */
+class DruidStore {
+    constructor(options = {}) {
+        this.name = 'druid';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.endpoint = options.endpoint ?? exports.DEFAULT_DRUID_ENDPOINT;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    // ---------------------------------------------------------------------
+    // 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) HTTP client. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('Not connected to Druid. Call connect() first.', {
+                database: 'druid',
+                host: this.endpoint,
+            });
+        }
+        return this.client;
+    }
+    async post(path, body, action) {
+        const client = this.requireClient();
+        try {
+            return await client.post(path, body);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Druid ${action} failed: ${parent.message}` });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Query API
+    // ---------------------------------------------------------------------
+    /**
+     * Run a Druid SQL query via `POST /druid/v2/sql`. Optional positional
+     * `params` are sent as Druid SQL parameters (`{ value }` objects). Druid
+     * returns an array of row objects, which is returned as-is.
+     */
+    async query(sql, params) {
+        const body = { query: sql };
+        if (params && params.length > 0) {
+            body.parameters = params.map((value) => ({ value }));
+        }
+        const rows = await this.post('/druid/v2/sql', body, 'query');
+        return (rows ?? []);
+    }
+    /**
+     * Run a native (JSON) Druid query via `POST /druid/v2`. Returns the parsed
+     * response body (shape depends on the native query type).
+     */
+    async nativeQuery(spec) {
+        return (await this.post('/druid/v2', spec, 'nativeQuery'));
+    }
+    // ---------------------------------------------------------------------
+    // Ingestion (indexing tasks)
+    // ---------------------------------------------------------------------
+    /**
+     * Ingest `rows` into datasource `target` by submitting an inline
+     * `index_parallel` task to `POST /druid/indexer/v1/task`. Returns the task
+     * submission response (typically `{ task: '<id>' }`).
+     */
+    async ingest(target, rows) {
+        const spec = {
+            type: 'index_parallel',
+            spec: {
+                dataSchema: { dataSource: target },
+                ioConfig: {
+                    type: 'index_parallel',
+                    inputSource: {
+                        type: 'inline',
+                        data: rows.map((r) => JSON.stringify(r)).join('\n'),
+                    },
+                    inputFormat: { type: 'json' },
+                },
+            },
+        };
+        return this.submitTask(spec);
+    }
+    /** Submit an arbitrary task spec to `POST /druid/indexer/v1/task`. */
+    async submitTask(spec) {
+        return this.post('/druid/indexer/v1/task', spec, 'submitTask');
+    }
+}
+exports.DruidStore = DruidStore;
+exports.default = DruidStore;