ts-prorm-orm 1.1.0

package/dist/nosql/firestore/index.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Google Cloud Firestore store implementation for the Prorm NoSQL layer.
+ *
+ * Firestore is a document database organized as collections of documents,
+ * each addressed by an id, with rich structured querying. It does not fit the
+ * SQL-shaped `Dialect` interface, so this class implements the minimal
+ * `NoSqlStore` marker interface for connection lifecycle and exposes
+ * Firestore's real `collection().doc()` CRUD plus `where()` query API through
+ * a small convenience layer.
+ *
+ * Uses the official `@google-cloud/firestore` driver. 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.FirestoreStore = void 0;
+const errors_1 = require("../../errors");
+class FirestoreStore {
+    constructor(options = {}) {
+        this.name = 'firestore';
+        this.library = '@google-cloud/firestore';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // 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('@google-cloud/firestore');
+                const FirestoreCtor = mod.Firestore ?? mod;
+                this.client = new FirestoreCtor({
+                    projectId: this.options.projectId,
+                    keyFilename: this.options.keyFilename,
+                });
+            }
+            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 Firestore: ${parent.message}`, {
+                parent,
+                database: 'firestore',
+            });
+        }
+    }
+    async disconnect() {
+        if (this.client && typeof this.client.terminate === 'function') {
+            try {
+                await this.client.terminate();
+            }
+            catch (err) {
+                throw wrapDatabaseError(err, 'Firestore disconnect failed');
+            }
+        }
+        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 Firestore. Call connect() first.', {
+                database: 'firestore',
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // Document CRUD
+    // ---------------------------------------------------------------------
+    /**
+     * Add a document to `collection`. If `doc.id` is set the document is written
+     * to that id via `doc(id).set(doc)`; otherwise Firestore auto-assigns one
+     * via `collection.add(doc)`. Returns the resulting document id.
+     */
+    async insert(collection, doc) {
+        const client = this.requireClient();
+        try {
+            const explicitId = doc.id;
+            if (explicitId !== undefined && explicitId !== null) {
+                await client.collection(collection).doc(String(explicitId)).set(doc);
+                return String(explicitId);
+            }
+            const ref = await client.collection(collection).add(doc);
+            return ref?.id;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Firestore insert failed');
+        }
+    }
+    /** Fetch a document by id, returning its data (or `undefined` if missing). */
+    async get(collection, id) {
+        const client = this.requireClient();
+        try {
+            const snap = await client.collection(collection).doc(id).get();
+            return snap?.exists ? snap.data() : undefined;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Firestore get failed');
+        }
+    }
+    /** Partially update a document by id, returning the applied `patch`. */
+    async update(collection, id, patch) {
+        const client = this.requireClient();
+        try {
+            await client.collection(collection).doc(id).update(patch);
+            return patch;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Firestore update failed');
+        }
+    }
+    /** Delete a document by id. */
+    async delete(collection, id) {
+        const client = this.requireClient();
+        try {
+            return await client.collection(collection).doc(id).delete();
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Firestore delete failed');
+        }
+    }
+    /**
+     * Query `collection`. `filter` may be an array of `[field, op, value]`
+     * conditions or a plain object (treated as equality on each key). Returns
+     * the matched documents, each shaped as `{ id, ...data }`.
+     */
+    async query(collection, filter = {}) {
+        const client = this.requireClient();
+        try {
+            let ref = client.collection(collection);
+            for (const [field, op, value] of normalizeConditions(filter)) {
+                ref = ref.where(field, op, value);
+            }
+            const snapshot = await ref.get();
+            const docs = snapshot?.docs ?? [];
+            return docs.map((d) => ({ id: d.id, ...d.data() }));
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'Firestore query failed');
+        }
+    }
+}
+exports.FirestoreStore = FirestoreStore;
+function normalizeConditions(filter) {
+    if (Array.isArray(filter)) {
+        return filter;
+    }
+    return Object.entries(filter).map(([field, value]) => [field, '==', value]);
+}
+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 = FirestoreStore;

package/dist/nosql/fluree/index.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Fluree store implementation.
+ *
+ * Fluree is an immutable, time-travel ledger database: every transaction is
+ * appended as a set of cryptographically-hashed "flakes" into a blockchain-
+ * like log, so no data is ever overwritten and any past state (by block or
+ * time) is queryable. It speaks a JSON query/transaction API (FlureeQL) over
+ * HTTP, not SQL.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Fluree has no single canonical npm client; it is an HTTP/JSON API. Like the
+ * Prometheus store, this class talks to the server with the global `fetch`
+ * (so `library === 'fetch'`) and accepts an injected HTTP client via
+ * `FlureeStoreOptions.client` for tests / custom transports. It implements the
+ * minimal `NoSqlStore` marker interface plus the shared ledger surface:
+ *  - `append(collection, data)` -> `POST /fdb/<ledger>/transact`.
+ *  - `get(collection, id)`      -> `POST /fdb/<ledger>/query`.
+ *  - `history(collection, id)`  -> `POST /fdb/<ledger>/history`.
+ *  - `verify(collection, id)`   -> `POST /fdb/<ledger>/history` with block
+ *    metadata (the flake's block hash is its tamper-evidence proof).
+ *  - `query(flureeql)`          -> raw `POST /fdb/<ledger>/query`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlureeStore = exports.DEFAULT_FLUREE_BASE_URL = void 0;
+exports.createFlureeFetchClient = createFlureeFetchClient;
+const errors_1 = require("../../errors");
+/** Default Fluree HTTP API base URL. */
+exports.DEFAULT_FLUREE_BASE_URL = 'http://localhost:8090';
+/** Build a `fetch`-backed JSON client for the given base URL. */
+function createFlureeFetchClient(baseURL, headers) {
+    const root = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL;
+    return {
+        async post(path, body) {
+            const res = await fetch(`${root}${path}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...(headers ?? {}) },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            }
+            return res.json();
+        },
+    };
+}
+/**
+ * `FlureeStore` wraps Fluree's HTTP query/transact API behind the shared
+ * ledger surface.
+ */
+class FlureeStore {
+    constructor(options) {
+        this.name = 'fluree';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        if (!options || !options.ledger) {
+            throw new errors_1.DatabaseError('FlureeStore requires a `ledger` name', {
+                code: 'INVALID_CONNECTION',
+            });
+        }
+        this.baseURL = options.baseURL ?? exports.DEFAULT_FLUREE_BASE_URL;
+        this.ledger = options.ledger;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        this.client = this.injectedClient ?? createFlureeFetchClient(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 Fluree', {
+                database: 'fluree',
+                host: this.baseURL,
+            });
+        }
+        return this.client;
+    }
+    endpoint(op) {
+        return `/fdb/${this.ledger}/${op}`;
+    }
+    async post(op, body, action) {
+        const client = this.requireClient();
+        try {
+            return await client.post(this.endpoint(op), body);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Fluree ${action} failed: ${parent.message}` });
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Ledger surface
+    // ---------------------------------------------------------------------
+    /**
+     * Append `data` to `collection` as a transaction (`POST .../transact`).
+     * Returns the transaction response (block, flakes, temp-id map, and the
+     * block hash that anchors the write into the immutable log).
+     */
+    async append(collection, data) {
+        return this.post('transact', [{ _id: collection, ...data }], 'append');
+    }
+    /** Read subject `id` from `collection` (`POST .../query`). */
+    async get(collection, id) {
+        return this.post('query', { select: ['*'], from: [[`${collection}/id`, id]] }, 'get');
+    }
+    /** Return the flake-level history of subject `id` (`POST .../history`). */
+    async history(collection, id) {
+        return this.post('history', { history: [[`${collection}/id`, id]] }, 'history');
+    }
+    /**
+     * Return the provenance/proof for subject `id`: its history with block
+     * metadata (`meta: true`), so callers see the block hash and instant that
+     * cryptographically anchor each revision into Fluree's tamper-evident log.
+     */
+    async verify(collection, id) {
+        return this.post('history', { history: [[`${collection}/id`, id]], meta: true }, 'verify');
+    }
+    /** Run a raw FlureeQL query object (`POST .../query`). */
+    async query(flureeql) {
+        return this.post('query', flureeql, 'query');
+    }
+    /** Run a raw FlureeQL transaction (`POST .../transact`). */
+    async transact(transaction) {
+        return this.post('transact', transaction, 'transact');
+    }
+}
+exports.FlureeStore = FlureeStore;
+exports.default = FlureeStore;

package/dist/nosql/fuseki/index.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Apache Jena Fuseki store implementation.
+ *
+ * Fuseki is a SPARQL server over the Jena RDF triplestore. It is queried and
+ * updated entirely over HTTP using the SPARQL 1.1 Protocol: a dataset exposes
+ * a query endpoint (`/<dataset>/query`) and an update endpoint
+ * (`/<dataset>/update`). 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`
+ *
+ * Fuseki has no dedicated npm client; it is just a SPARQL/HTTP endpoint.
+ * Rather than depend on any package, 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 `FusekiStoreOptions.client`; when
+ * omitted, a tiny internal client over `fetch` + `endpoint` is built at
+ * connect time.
+ *
+ * ## Surface
+ *
+ * - `query(sparql)`  -> POST to `/<dataset>/query`, returns result bindings
+ * - `update(sparql)` -> POST to `/<dataset>/update`
+ * - `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.FusekiStore = exports.DEFAULT_FUSEKI_DATASET = exports.DEFAULT_FUSEKI_ENDPOINT = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Fuseki base URL. */
+exports.DEFAULT_FUSEKI_ENDPOINT = 'http://localhost:3030';
+/** Default dataset name. */
+exports.DEFAULT_FUSEKI_DATASET = 'ds';
+/** 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;
+        },
+    };
+}
+/**
+ * `FusekiStore` wraps a Fuseki dataset's SPARQL query/update endpoints behind
+ * the `NoSqlStore` lifecycle.
+ */
+class FusekiStore {
+    constructor(options = {}) {
+        this.name = 'fuseki';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.endpoint = options.endpoint ?? exports.DEFAULT_FUSEKI_ENDPOINT;
+        this.dataset = options.dataset ?? exports.DEFAULT_FUSEKI_DATASET;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    /** SPARQL query endpoint path for the configured dataset. */
+    get queryPath() {
+        return `/${this.dataset}/query`;
+    }
+    /** SPARQL update endpoint path for the configured dataset. */
+    get updatePath() {
+        return `/${this.dataset}/update`;
+    }
+    // ---------------------------------------------------------------------
+    // 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 Fuseki', {
+                database: 'fuseki',
+                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: `Fuseki 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: `Fuseki 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: `Fuseki 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.FusekiStore = FusekiStore;

package/dist/nosql/gcs/index.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GCSStore = void 0;
+/**
+ * Google Cloud Storage (GCS) store.
+ *
+ * GCS is an object store, not a SQL database - it has no query language,
+ * no joins, and no ad hoc WHERE-clause filtering. Data lives as immutable
+ * objects (blobs) addressed by `(bucket, key)`, so it does not fit the
+ * SQL-shaped `Dialect` interface (`src/dialects/dialect.ts`). This store
+ * instead implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes GCS's own object-level operations
+ * (upload/download/delete/exists/list/metadata) directly.
+ *
+ * Built on the `@google-cloud/storage` driver. That package is loaded
+ * lazily inside `connect()` (via `require`) rather than imported at module
+ * top level, so importing this file never pulls in the (optional) SDK.
+ * Tests inject a pre-built `Storage`-shaped mock via the `client` option,
+ * which skips the `require` entirely.
+ */
+const errors_1 = require("../../errors");
+/**
+ * Google Cloud Storage store, implementing the minimal `NoSqlStore` marker
+ * interface. Unlike the SQL dialects there is no `query(sql)` - GCS's
+ * operations are object-shaped (`bucket(name).file(key).<op>()`) and that
+ * shape is preserved here rather than forced into a SQL string.
+ */
+class GCSStore {
+    constructor(options = {}) {
+        this.name = 'gcs';
+        this.library = '@google-cloud/storage';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // NoSqlStore lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            if (this.options.client) {
+                // A pre-built Storage instance was injected - use it as-is and skip
+                // loading the (optional) SDK entirely.
+                this.client = this.options.client;
+            }
+            else {
+                // Lazy-load the driver so importing this module never requires the
+                // optional `@google-cloud/storage` package to be installed.
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const gcs = require('@google-cloud/storage');
+                this.client = new gcs.Storage({
+                    projectId: this.options.projectId,
+                    keyFilename: this.options.keyFilename,
+                });
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            throw new errors_1.ConnectionError(`Failed to connect to Google Cloud Storage: ${err instanceof Error ? err.message : String(err)}`, { parent: err instanceof Error ? err : undefined, database: 'gcs' });
+        }
+    }
+    async disconnect() {
+        // The GCS client is stateless (HTTP-based) with nothing to close, so
+        // disconnecting just drops the reference.
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `@google-cloud/storage` `Storage` client for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('Not connected to Google Cloud Storage. Call connect() first.', {
+                database: 'gcs',
+            });
+        }
+        return this.client;
+    }
+    /** Resolve a `File` handle for `(bucket, key)` off the live client. */
+    file(bucket, key) {
+        return this.requireClient().bucket(bucket).file(key);
+    }
+    wrapError(action, err) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        return errors_1.DatabaseError.from(parent, { message: `GCS ${action} failed: ${parent.message}` });
+    }
+    // ---------------------------------------------------------------------
+    // Object operations
+    // ---------------------------------------------------------------------
+    /**
+     * Upload (or overwrite) an object. `data` may be a `Buffer` or string;
+     * `options` is passed straight through to `file.save()` (e.g.
+     * `{ contentType, metadata, resumable }`).
+     */
+    async uploadObject(bucket, key, data, options = {}) {
+        const file = this.file(bucket, key);
+        try {
+            await file.save(data, options);
+        }
+        catch (err) {
+            throw this.wrapError(`upload of '${key}' to '${bucket}'`, err);
+        }
+    }
+    /** Download an object's contents as a `Buffer`. Throws if the object does not exist. */
+    async downloadObject(bucket, key) {
+        const file = this.file(bucket, key);
+        try {
+            const [contents] = await file.download();
+            return contents;
+        }
+        catch (err) {
+            throw this.wrapError(`download of '${key}' from '${bucket}'`, err);
+        }
+    }
+    /** Delete an object. Throws if the object does not exist. */
+    async deleteObject(bucket, key) {
+        const file = this.file(bucket, key);
+        try {
+            await file.delete();
+        }
+        catch (err) {
+            throw this.wrapError(`delete of '${key}' from '${bucket}'`, err);
+        }
+    }
+    /** Returns whether an object exists. */
+    async objectExists(bucket, key) {
+        const file = this.file(bucket, key);
+        try {
+            const [exists] = await file.exists();
+            return exists;
+        }
+        catch (err) {
+            throw this.wrapError(`exists check of '${key}' in '${bucket}'`, err);
+        }
+    }
+    /**
+     * List objects in a bucket, optionally restricted to those whose name
+     * starts with `prefix`. Returns the raw `File` objects from the driver.
+     */
+    async listObjects(bucket, prefix) {
+        const handle = this.requireClient().bucket(bucket);
+        try {
+            const [files] = await handle.getFiles({ prefix });
+            return (files ?? []);
+        }
+        catch (err) {
+            throw this.wrapError(`list of '${bucket}'`, err);
+        }
+    }
+    /** Fetch an object's metadata (size, contentType, updated, custom metadata, etc). */
+    async getMetadata(bucket, key) {
+        const file = this.file(bucket, key);
+        try {
+            const [metadata] = await file.getMetadata();
+            return metadata;
+        }
+        catch (err) {
+            throw this.wrapError(`getMetadata of '${key}' in '${bucket}'`, err);
+        }
+    }
+}
+exports.GCSStore = GCSStore;
+exports.default = GCSStore;