ts-prorm-orm 1.1.0

package/dist/nosql/coherence/index.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Oracle Coherence store implementation.
+ *
+ * Oracle Coherence is a distributed in-memory data grid. Data lives in named
+ * caches (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 Coherence's cache operations
+ * (getMap/put/get/remove/keys/size) as a typed, promise-based API.
+ *
+ * ## Transport: the Coherence REST API over `fetch`
+ *
+ * Coherence exposes a language-neutral REST API rather than a canonical
+ * Node.js driver, so this store talks to it with the global `fetch` (exactly
+ * like `PrometheusStore`) and `library` is `'fetch'`. For tests (and callers
+ * who want their own transport) an alternative client can be injected via
+ * `CoherenceStoreOptions.client`; when omitted a tiny internal `fetch`
+ * client is built at connect time.
+ *
+ * Endpoints wrapped (cache name is the first path segment):
+ * - `mapPut`    -> `PUT    /<cache>/<key>`
+ * - `mapGet`    -> `GET    /<cache>/<key>`
+ * - `mapRemove` -> `DELETE /<cache>/<key>`
+ * - `mapKeys`   -> `GET    /<cache>/keys`
+ * - `mapSize`   -> `GET    /<cache>/count`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoherenceStore = exports.DEFAULT_COHERENCE_BASE_URL = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Coherence REST base URL. */
+exports.DEFAULT_COHERENCE_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;
+/**
+ * `CoherenceStore` wraps Coherence's REST API behind the `NoSqlStore`
+ * lifecycle and exposes named-cache key/value operations.
+ */
+class CoherenceStore {
+    constructor(options = {}) {
+        this.name = 'coherence';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        /** Cached cache handles, keyed by name so `getMap` is idempotent. */
+        this.caches = new Map();
+        this.baseURL = options.baseURL ?? exports.DEFAULT_COHERENCE_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.caches.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 Coherence', {
+                database: 'coherence',
+                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: `Coherence ${action} failed: ${parent.message}` });
+    }
+    // ---------------------------------------------------------------------
+    // Distributed cache operations
+    // ---------------------------------------------------------------------
+    /** Resolve (and cache) a named-cache handle. */
+    async getMap(name) {
+        this.requireClient();
+        let cache = this.caches.get(name);
+        if (!cache) {
+            cache = { name };
+            this.caches.set(name, cache);
+        }
+        return cache;
+    }
+    /** Store `value` under `key` in `map` (`PUT /<cache>/<key>`). */
+    async mapPut(map, key, value) {
+        const client = this.requireClient();
+        try {
+            await client.put(`/${enc(map.name)}/${enc(key)}`, JSON.stringify(value));
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapPut');
+        }
+    }
+    /** Read `key` from `map` (`GET /<cache>/<key>`); `null` if absent. */
+    async mapGet(map, key) {
+        const client = this.requireClient();
+        try {
+            return await client.get(`/${enc(map.name)}/${enc(key)}`);
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapGet');
+        }
+    }
+    /** Remove `key` from `map` (`DELETE /<cache>/<key>`). */
+    async mapRemove(map, key) {
+        const client = this.requireClient();
+        try {
+            return await client.delete(`/${enc(map.name)}/${enc(key)}`);
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapRemove');
+        }
+    }
+    /** List all keys in `map` (`GET /<cache>/keys`). */
+    async mapKeys(map) {
+        const client = this.requireClient();
+        try {
+            const body = await client.get(`/${enc(map.name)}/keys`);
+            if (Array.isArray(body))
+                return body;
+            if (body && Array.isArray(body.keys))
+                return body.keys;
+            return body == null ? [] : [body];
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapKeys');
+        }
+    }
+    /** Number of entries in `map` (`GET /<cache>/count`). */
+    async mapSize(map) {
+        const client = this.requireClient();
+        try {
+            const body = await client.get(`/${enc(map.name)}/count`);
+            return Number(body) || 0;
+        }
+        catch (err) {
+            throw this.wrap(err, 'mapSize');
+        }
+    }
+}
+exports.CoherenceStore = CoherenceStore;
+exports.default = CoherenceStore;

package/dist/nosql/cosmosdb/index.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Azure Cosmos DB store implementation for the Prorm NoSQL layer.
+ *
+ * Cosmos DB is a multi-model database (document, key/value, graph, column)
+ * exposed here through its document (SQL/Core) API. Documents live in a
+ * container within a database and are addressed by an `id`. It does not fit
+ * the SQL-shaped `Dialect` interface (no identifier escaping, no DDL
+ * builder), so this class implements the minimal `NoSqlStore` marker
+ * interface for connection lifecycle and otherwise exposes Cosmos DB's real
+ * item CRUD plus SQL query API directly.
+ *
+ * Uses the official `@azure/cosmos` SDK. 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 `client`
+ * via `options.client`, which bypasses the lazy `require` entirely - no real
+ * driver and no network are needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosDbStore = void 0;
+const errors_1 = require("../../errors");
+class CosmosDbStore {
+    constructor(options = {}) {
+        this.name = 'cosmosdb';
+        this.library = '@azure/cosmos';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+        this.defaultDatabase = options.database ?? 'default';
+        this.defaultContainer = options.container ?? 'default';
+    }
+    // ---------------------------------------------------------------------
+    // 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('@azure/cosmos');
+                const CosmosClientCtor = mod.CosmosClient;
+                this.client = new CosmosClientCtor({
+                    endpoint: this.options.endpoint,
+                    key: this.options.key,
+                });
+            }
+            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 Cosmos DB: ${parent.message}`, {
+                parent,
+                database: 'cosmosdb',
+            });
+        }
+    }
+    async disconnect() {
+        // The Cosmos SDK client holds no long-lived socket that must be closed;
+        // dispose the reference so subsequent calls require a fresh connect().
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('Not connected to Cosmos DB. Call connect() first.', {
+                database: 'cosmosdb',
+            });
+        }
+        return this.client;
+    }
+    /** Resolves a container handle via `database(db).container(container)`. */
+    container(container, database) {
+        const client = this.requireClient();
+        const db = client.database(database ?? this.defaultDatabase);
+        return db.container(container ?? this.defaultContainer);
+    }
+    // ---------------------------------------------------------------------
+    // Document CRUD
+    // ---------------------------------------------------------------------
+    /** Create a document; returns its `id`. */
+    async insert(collection, doc) {
+        try {
+            const result = await this.container(collection).items.create(doc);
+            return result?.resource?.id ?? doc.id;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Cosmos DB insert failed');
+        }
+    }
+    /** Read a document by id, returning its stored resource. */
+    async get(collection, id) {
+        try {
+            const result = await this.container(collection).item(id).read();
+            return result?.resource;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Cosmos DB get failed');
+        }
+    }
+    /** Merge `patch` into the existing document and replace it. */
+    async update(collection, id, patch) {
+        try {
+            const item = this.container(collection).item(id);
+            const current = await item.read();
+            const merged = { ...(current?.resource ?? {}), ...patch, id };
+            const result = await item.replace(merged);
+            return result?.resource ?? merged;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Cosmos DB update failed');
+        }
+    }
+    /** Delete a document by id. */
+    async delete(collection, id) {
+        try {
+            return await this.container(collection).item(id).delete();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Cosmos DB delete failed');
+        }
+    }
+    /**
+     * Run a Cosmos SQL query (string or `SqlQuerySpec`) against `collection`
+     * and return the matched resources.
+     */
+    async query(collection, statement, options = {}) {
+        try {
+            const result = await this.container(collection).items.query(statement, options).fetchAll();
+            return result?.resources ?? [];
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Cosmos DB query failed');
+        }
+    }
+}
+exports.CosmosDbStore = CosmosDbStore;
+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 = CosmosDbStore;

package/dist/nosql/couchbase/index.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Couchbase store implementation for the Prorm NoSQL layer.
+ *
+ * Couchbase is a distributed document/key-value store. Documents live in a
+ * bucket, are addressed by an opaque key within a scope/collection, and can
+ * additionally be queried with N1QL (SQL++). It does not fit the SQL-shaped
+ * `Dialect` interface (no identifier escaping, no DDL builder), so this class
+ * implements the minimal `NoSqlStore` marker interface for connection
+ * lifecycle and otherwise exposes Couchbase's real key/value CRUD plus N1QL
+ * query API directly rather than forcing everything through `query(sql)`.
+ *
+ * Uses the official `couchbase` Node.js SDK. 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
+ * `cluster` via `options.cluster`, which bypasses the lazy `require`
+ * entirely - no real driver and no network are needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CouchbaseStore = void 0;
+const errors_1 = require("../../errors");
+const DEFAULT_BUCKET = 'default';
+const DEFAULT_SCOPE = '_default';
+const DEFAULT_COLLECTION = '_default';
+/**
+ * `CouchbaseStore` wraps the official `couchbase` SDK's
+ * `Cluster`/`Bucket`/`Collection` API in a small key/value CRUD plus N1QL
+ * convenience layer.
+ */
+class CouchbaseStore {
+    constructor(options = {}) {
+        this.name = 'couchbase';
+        this.library = 'couchbase';
+        this.cluster = null;
+        this.connected = false;
+        this.options = options;
+        this.defaultBucket = options.bucket ?? DEFAULT_BUCKET;
+        this.defaultScope = options.scope ?? DEFAULT_SCOPE;
+        this.defaultCollection = options.collection ?? DEFAULT_COLLECTION;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.cluster) {
+            return;
+        }
+        try {
+            if (this.options.cluster) {
+                // A pre-built cluster was injected (e.g. by tests) - use it as-is
+                // and skip loading the driver entirely.
+                this.cluster = this.options.cluster;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const cb = require('couchbase');
+                this.cluster = await cb.connect(this.options.connectionString, {
+                    username: this.options.username,
+                    password: this.options.password,
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.cluster = null;
+            this.connected = false;
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw new errors_1.ConnectionError(`Unable to connect to Couchbase: ${parent.message}`, {
+                parent,
+                database: 'couchbase',
+            });
+        }
+    }
+    async disconnect() {
+        if (!this.cluster) {
+            this.connected = false;
+            return;
+        }
+        try {
+            await this.cluster.close();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase disconnect failed');
+        }
+        finally {
+            this.cluster = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected && this.cluster !== null;
+    }
+    /** Returns the underlying native `Cluster` for anything not wrapped here. */
+    getClient() {
+        return this.requireCluster();
+    }
+    requireCluster() {
+        if (!this.cluster || !this.connected) {
+            throw new errors_1.ConnectionError('Not connected to Couchbase. Call connect() first.', {
+                database: 'couchbase',
+            });
+        }
+        return this.cluster;
+    }
+    // ---------------------------------------------------------------------
+    // Collection resolution
+    // ---------------------------------------------------------------------
+    /**
+     * Resolves a collection handle. With no arguments (or only a bucket) it
+     * uses the store's configured defaults; passing an explicit
+     * `scope`/`collection` targets a non-default collection via
+     * `bucket.scope(scope).collection(collection)`, otherwise it falls back to
+     * `bucket.defaultCollection()`.
+     */
+    collection(bucket, scope, collection) {
+        const cluster = this.requireCluster();
+        try {
+            const bucketName = bucket ?? this.defaultBucket;
+            const scopeName = scope ?? this.defaultScope;
+            const collectionName = collection ?? this.defaultCollection;
+            const bucketHandle = cluster.bucket(bucketName);
+            if (scopeName === DEFAULT_SCOPE && collectionName === DEFAULT_COLLECTION) {
+                return bucketHandle.defaultCollection();
+            }
+            return bucketHandle.scope(scopeName).collection(collectionName);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase collection resolution failed');
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Key/value CRUD (against the default collection)
+    // ---------------------------------------------------------------------
+    /** Insert a new document; fails if the key already exists. */
+    async insert(id, doc) {
+        try {
+            return await this.collection().insert(id, doc);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase insert failed');
+        }
+    }
+    /** Insert or replace a document by key. */
+    async upsert(id, doc) {
+        try {
+            return await this.collection().upsert(id, doc);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase upsert failed');
+        }
+    }
+    /** Fetch a document by key, returning its `.content` (the stored value). */
+    async get(id) {
+        try {
+            const result = await this.collection().get(id);
+            return result?.content;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase get failed');
+        }
+    }
+    /** Replace an existing document; fails if the key does not exist. */
+    async replace(id, doc) {
+        try {
+            return await this.collection().replace(id, doc);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase replace failed');
+        }
+    }
+    /** Remove a document by key. */
+    async remove(id) {
+        try {
+            return await this.collection().remove(id);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase remove failed');
+        }
+    }
+    // ---------------------------------------------------------------------
+    // N1QL (SQL++) queries
+    // ---------------------------------------------------------------------
+    /**
+     * Run a N1QL/SQL++ `statement` against the cluster and return its result
+     * rows. `options.parameters` binds positional (array) or named (object)
+     * parameters into the statement.
+     */
+    async query(statement, options = {}) {
+        const cluster = this.requireCluster();
+        try {
+            const { parameters, ...rest } = options;
+            const result = await cluster.query(statement, { parameters, ...rest });
+            return result?.rows ?? [];
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Couchbase query failed');
+        }
+    }
+}
+exports.CouchbaseStore = CouchbaseStore;
+/**
+ * Wrap a raw driver error in a `DatabaseError`, preserving the original text.
+ * A `ConnectionError` (e.g. "not connected") is passed through unchanged so
+ * callers can still distinguish connection failures from operation failures.
+ */
+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 = CouchbaseStore;