@gensx/storage/dist/cjs/database/databaseClient.cjs

Cloud storage, blobs, sqlite, and vector database providers/hooks for GenSX.

'use strict';

/**
* Check out the docs at https://www.gensx.com/docs
* Find us on Github https://github.com/gensx-inc/gensx
* Find us on Discord https://discord.gg/F5BSU8Kc
*/

var path = require('path');
var config = require('../utils/config.cjs');

/**
 * Client for interacting with database functionality outside of JSX context
 */
class DatabaseClient {
    storagePromise = null;
    options;
    /**
     * Create a new DatabaseClient
     * @param options Optional configuration properties for the database storage
     */
    constructor(options = {}) {
        this.options = options;
    }
    /**
     * Lazy initialization of storage
     */
    async getStorage() {
        this.storagePromise ??= this.initializeStorage().catch((error) => {
            // Clear the failed promise to allow retry on next call
            this.storagePromise = null;
            throw error;
        });
        return this.storagePromise;
    }
    async initializeStorage() {
        const kind = this.options.kind ??
            (process.env.GENSX_RUNTIME === "cloud" ? "cloud" : "filesystem");
        if (kind === "filesystem") {
            const { FileSystemDatabaseStorage } = await Promise.resolve().then(function () { return require('./filesystem.cjs'); });
            const rootDir = this.options.kind === "filesystem" && this.options.rootDir
                ? this.options.rootDir
                : path.join(process.cwd(), ".gensx", "databases");
            return new FileSystemDatabaseStorage(rootDir);
        }
        else {
            const { RemoteDatabaseStorage } = await Promise.resolve().then(function () { return require('./remote.cjs'); });
            const { project, environment } = config.getProjectAndEnvironment({
                project: this.options.project,
                environment: this.options.environment,
            });
            return new RemoteDatabaseStorage(project, environment);
        }
    }
    /**
     * Get a database (ensures it exists first)
     * @param name The database name
     * @returns A Promise resolving to a Database
     */
    async getDatabase(name) {
        const storage = await this.getStorage();
        if (!storage.hasEnsuredDatabase(name)) {
            await storage.ensureDatabase(name);
        }
        return storage.getDatabase(name);
    }
    /**
     * Ensure a database exists (idempotent operation)
     * @param name The database name
     * @returns A Promise resolving to the ensure result
     */
    async ensureDatabase(name) {
        const storage = await this.getStorage();
        return storage.ensureDatabase(name);
    }
    /**
     * List all databases
     * @param options Optional pagination options
     * @returns A Promise resolving to an array of database names and optional next cursor
     */
    async listDatabases(options) {
        const storage = await this.getStorage();
        return storage.listDatabases(options);
    }
    /**
     * Delete a database
     * @param name The database name
     * @returns A Promise resolving to the deletion result
     */
    async deleteDatabase(name) {
        const storage = await this.getStorage();
        return storage.deleteDatabase(name);
    }
    /**
     * Check if a database exists
     * @param name The database name
     * @returns A Promise resolving to a boolean indicating if the database exists
     */
    async databaseExists(name) {
        const storage = await this.getStorage();
        const result = await storage.listDatabases();
        return result.databases.some((db) => db.name === name);
    }
}

exports.DatabaseClient = DatabaseClient;
//# sourceMappingURL=databaseClient.cjs.map