ts-prorm-orm 1.1.0

package/dist/nosql/minio/index.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinioStore = void 0;
+/**
+ * MinIO object-storage store.
+ *
+ * MinIO is a self-hostable, S3-compatible object store. Like Amazon S3 it has
+ * no query language, no rows, and no SQL-shaped access pattern — data is
+ * opaque objects (byte bodies plus metadata) addressed by a `(bucket, key)`
+ * pair, where the "key" is a flat object name that only *looks* like a path
+ * (`foo/bar/baz.json`). None of that fits the SQL-shaped `Dialect` interface,
+ * so this store implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes MinIO's own object-level operations
+ * directly.
+ *
+ * Unlike `S3Store` (which uses the AWS SDK v3 command pattern), this store is
+ * built on the official `minio` JS client, whose `Minio.Client` exposes
+ * method-per-operation (`putObject`, `getObject`, `removeObject`, …). Two of
+ * those methods are *stream*-shaped rather than promise-of-value:
+ *
+ *   - `getObject(bucket, key)` resolves to a readable byte stream. This store
+ *     collects that stream to completion into a single `Buffer` so callers get
+ *     the whole object body without wiring up stream plumbing themselves.
+ *   - `listObjects(bucket, prefix, recursive)` returns an object stream that
+ *     emits one item per object. This store collects that stream into an array
+ *     of object *names* (`item.name`).
+ *
+ * The `minio` package is loaded lazily inside `connect()` (via `require`)
+ * rather than a top-level import so that importing this module doesn't
+ * hard-require `minio` unless a MinIO store is actually connected — and so
+ * tests can inject a pre-built mock `client` and never load the driver at all.
+ */
+const errors_1 = require("../../errors");
+/**
+ * MinIO store, implementing the minimal `NoSqlStore` marker interface. Unlike
+ * the SQL dialects there is no `query(sql)` — MinIO's operations are
+ * object-shaped and that shape is preserved here rather than forced into a
+ * SQL string.
+ */
+class MinioStore {
+    constructor(options = {}) {
+        this.name = 'minio';
+        this.library = 'minio';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // NoSqlStore lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        try {
+            if (this.options.client) {
+                // A pre-built client was injected (mock or custom). Use it directly
+                // and don't require the driver at all.
+                this.client = this.options.client;
+            }
+            else {
+                const Minio = require('minio');
+                this.client = new Minio.Client({
+                    endPoint: this.options.endPoint,
+                    port: this.options.port,
+                    useSSL: this.options.useSSL,
+                    accessKey: this.options.accessKey,
+                    secretKey: this.options.secretKey,
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.connected = false;
+            this.client = null;
+            throw new errors_1.ConnectionError(`Failed to connect to MinIO: ${err instanceof Error ? err.message : String(err)}`, { parent: err instanceof Error ? err : undefined });
+        }
+    }
+    async disconnect() {
+        // The MinIO client is stateless (no persistent socket to close), so
+        // disconnecting just drops the reference.
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `Minio.Client` (loosely typed) for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('MinIO client is not connected. Call connect() first.');
+        }
+        return this.client;
+    }
+    /** Wraps a driver failure in a `DatabaseError`, preserving the original error. */
+    wrapError(action, err) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        const name = parent.name ? ` (${parent.name})` : '';
+        return new errors_1.DatabaseError(`MinIO ${action} failed${name}: ${parent.message}`, {
+            parent,
+            original: parent.message,
+        });
+    }
+    // ---------------------------------------------------------------------
+    // Object operations
+    // ---------------------------------------------------------------------
+    /** `putObject` — store an object's body (and optional metadata) under `bucket`/`key`. */
+    async putObject(bucket, key, data, options = {}) {
+        const client = this.requireClient();
+        try {
+            // The modern `minio` client resolves to an `UploadedObjectInfo`
+            // (`{ etag, versionId }`). `size`/`metadata` are optional trailing args.
+            const result = await client.putObject(bucket, key, data, options.size, options.metadata);
+            return { etag: result?.etag, versionId: result?.versionId };
+        }
+        catch (err) {
+            throw this.wrapError(`putObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /**
+     * `getObject` — fetch an object. `Minio.Client.getObject` resolves to a
+     * readable *byte stream*; this method collects that stream to completion
+     * into a single `Buffer` so callers get the whole body without wiring up
+     * stream plumbing. Optionally attaches a companion `statObject` result.
+     */
+    async getObject(bucket, key) {
+        const client = this.requireClient();
+        try {
+            const stream = await client.getObject(bucket, key);
+            const body = await this.collectStream(stream);
+            return { body };
+        }
+        catch (err) {
+            throw this.wrapError(`getObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /** `removeObject` — delete an object. */
+    async removeObject(bucket, key) {
+        const client = this.requireClient();
+        try {
+            await client.removeObject(bucket, key);
+        }
+        catch (err) {
+            throw this.wrapError(`removeObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /**
+     * `listObjects` — list objects in `bucket`, optionally restricted to those
+     * whose name starts with `prefix`. `Minio.Client.listObjects` returns an
+     * *object stream* that emits one item per object; this method collects that
+     * stream into an array of object *names* (`item.name`). Listing is recursive
+     * so nested "path"-style keys are all returned.
+     */
+    async listObjects(bucket, prefix) {
+        const client = this.requireClient();
+        try {
+            const stream = client.listObjects(bucket, prefix ?? '', true);
+            const items = await this.collectObjectStream(stream);
+            return items
+                .map((item) => item?.name ?? item?.prefix)
+                .filter((name) => typeof name === 'string');
+        }
+        catch (err) {
+            throw this.wrapError(`listObjects on '${bucket}'`, err);
+        }
+    }
+    /** `statObject` — fetch an object's metadata without its body. */
+    async statObject(bucket, key) {
+        const client = this.requireClient();
+        try {
+            const stat = await client.statObject(bucket, key);
+            return {
+                size: stat?.size,
+                etag: stat?.etag,
+                lastModified: stat?.lastModified,
+                metaData: stat?.metaData,
+            };
+        }
+        catch (err) {
+            throw this.wrapError(`statObject on '${bucket}/${key}'`, err);
+        }
+    }
+    /** `makeBucket` — create a bucket, optionally in a specific `region`. */
+    async makeBucket(bucket, region) {
+        const client = this.requireClient();
+        try {
+            if (region === undefined) {
+                await client.makeBucket(bucket);
+            }
+            else {
+                await client.makeBucket(bucket, region);
+            }
+        }
+        catch (err) {
+            throw this.wrapError(`makeBucket '${bucket}'`, err);
+        }
+    }
+    /** `bucketExists` — whether a bucket exists. */
+    async bucketExists(bucket) {
+        const client = this.requireClient();
+        try {
+            return Boolean(await client.bucketExists(bucket));
+        }
+        catch (err) {
+            throw this.wrapError(`bucketExists '${bucket}'`, err);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Stream collection helpers
+    // ---------------------------------------------------------------------
+    /**
+     * Collect a readable byte stream into a single `Buffer`. Supports both
+     * Node.js event-emitter streams (`.on('data'|'end'|'error')`) and async
+     * iterables (`for await`), so a test can inject either shape.
+     */
+    async collectStream(stream) {
+        if (stream && typeof stream.on === 'function') {
+            return new Promise((resolve, reject) => {
+                const chunks = [];
+                stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+                stream.on('end', () => resolve(Buffer.concat(chunks)));
+                stream.on('error', (err) => reject(err));
+            });
+        }
+        if (stream && typeof stream[Symbol.asyncIterator] === 'function') {
+            const chunks = [];
+            for await (const chunk of stream) {
+                chunks.push(Buffer.from(chunk));
+            }
+            return Buffer.concat(chunks);
+        }
+        // Nothing stream-like (e.g. already a Buffer/string) — coerce to Buffer.
+        if (Buffer.isBuffer(stream))
+            return stream;
+        if (stream == null)
+            return Buffer.alloc(0);
+        return Buffer.from(stream);
+    }
+    /**
+     * Collect an object stream into an array of emitted items. Supports both
+     * Node.js event-emitter streams and async iterables.
+     */
+    async collectObjectStream(stream) {
+        if (stream && typeof stream.on === 'function') {
+            return new Promise((resolve, reject) => {
+                const items = [];
+                stream.on('data', (item) => items.push(item));
+                stream.on('end', () => resolve(items));
+                stream.on('error', (err) => reject(err));
+            });
+        }
+        if (stream && typeof stream[Symbol.asyncIterator] === 'function') {
+            const items = [];
+            for await (const item of stream) {
+                items.push(item);
+            }
+            return items;
+        }
+        if (Array.isArray(stream))
+            return stream;
+        return [];
+    }
+}
+exports.MinioStore = MinioStore;
+exports.default = MinioStore;

package/dist/nosql/momento/index.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Momento Cache store implementation.
+ *
+ * Momento is a serverless, globally-available cache accessed through the
+ * `@gomomento/sdk` `CacheClient`. Every operation is scoped to a named
+ * cache. Momento has no SQL surface and no arbitrary key enumeration, so
+ * this class implements the minimal `NoSqlStore` marker interface and
+ * exposes an edge-KV `get`/`set`/`del`/`list`/`incr` surface mapped onto the
+ * Momento client.
+ *
+ * ## Driver
+ *
+ * Uses `@gomomento/sdk` (`CacheClient`). The driver is loaded lazily inside
+ * `connect()` (or supplied pre-built via the `client` option) so importing
+ * this module never requires `@gomomento/sdk` to be installed unless a store
+ * is actually connected. Tests inject a mock `client`.
+ *
+ * ## Method mapping
+ *
+ * - `get(key)`       -> `client.get(cacheName, key)`
+ * - `set(k,v,opts)`  -> `client.set(cacheName, key, value, { ttl })`
+ * - `del(key)`       -> `client.delete(cacheName, key)`
+ * - `list(name?)`    -> `client.listFetch(cacheName, listName)`. Momento has
+ *   no key-scan, so `list()` fetches the elements of a Momento *list*
+ *   (`name` is the list name, defaulting to `defaultListName`) rather than
+ *   enumerating cache keys.
+ * - `incr(k,by?)`    -> `client.increment(cacheName, key, by)`
+ *
+ * ## Serialization
+ *
+ * String values are stored verbatim; every other value is `JSON.stringify`'d
+ * before being written.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MomentoStore = void 0;
+const errors_1 = require("../../errors");
+function serialize(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+/**
+ * `MomentoStore` wraps a Momento `CacheClient` behind the `NoSqlStore`
+ * lifecycle and an edge-KV `get`/`set`/`del`/`list`/`incr` surface.
+ */
+class MomentoStore {
+    constructor(options = {}) {
+        this.name = 'momento';
+        this.library = '@gomomento/sdk';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    get cacheName() {
+        return this.options.cacheName ?? '';
+    }
+    // ---------------------------------------------------------------------
+    // 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('@gomomento/sdk');
+                const CacheClient = mod.CacheClient ?? mod.default?.CacheClient ?? mod.default;
+                this.client = new CacheClient({
+                    configuration: this.options.configuration,
+                    credentialProvider: this.options.credentialProvider,
+                    defaultTtlSeconds: this.options.defaultTtlSeconds,
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            throw wrapConnectionError(err, this.cacheName);
+        }
+    }
+    async disconnect() {
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying Momento `CacheClient` for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to Momento', {
+                database: 'momento',
+                host: this.cacheName,
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // Key-value operations
+    // ---------------------------------------------------------------------
+    /** Read a key from the configured cache. Returns the Momento response object. */
+    async get(key) {
+        const client = this.requireClient();
+        try {
+            return await client.get(this.cacheName, key);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'GET');
+        }
+    }
+    /**
+     * Write `value` under `key`. Strings are stored verbatim; other values are
+     * JSON-serialized. `options.ttl` sets a per-item TTL in seconds.
+     */
+    async set(key, value, options = {}) {
+        const client = this.requireClient();
+        try {
+            return await client.set(this.cacheName, key, serialize(value), options.ttl !== undefined ? { ttl: options.ttl } : undefined);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'SET');
+        }
+    }
+    /** Delete a key from the configured cache. */
+    async del(key) {
+        const client = this.requireClient();
+        try {
+            return await client.delete(this.cacheName, key);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'DEL');
+        }
+    }
+    /**
+     * Fetch the elements of a Momento list. Momento cannot enumerate cache
+     * keys, so `prefix`/`listName` names a list; defaults to
+     * `defaultListName`.
+     */
+    async list(listName) {
+        const client = this.requireClient();
+        try {
+            return await client.listFetch(this.cacheName, listName ?? this.options.defaultListName ?? '');
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'LIST');
+        }
+    }
+    /** Atomically increment the numeric value at `key` by `by` (default `1`). */
+    async incr(key, by = 1) {
+        const client = this.requireClient();
+        try {
+            return await client.increment(this.cacheName, key, by);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'INCR');
+        }
+    }
+}
+exports.MomentoStore = MomentoStore;
+function wrapConnectionError(err, host) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return new errors_1.ConnectionError(`Unable to connect to Momento: ${parent.message}`, {
+        parent,
+        database: 'momento',
+        host,
+    });
+}
+function wrapDatabaseError(err, action) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    return errors_1.DatabaseError.from(parent, { message: `Momento ${action} failed: ${parent.message}` });
+}
+exports.default = MomentoStore;