staticql/dist/src/repository/MultiRepository.js

Type-safe query engine for static content including Markdown, YAML, JSON, and more.

import { SourceConfigResolver } from "../SourceConfigResolver.js";
/**
 * MultiRepository: Wraps multiple StorageRepository instances to route
 * read operations per source and write operations to a designated repository.
 */
export class MultiRepository {
    constructor(defaultRepository, sourceRepositories, writeRepository) {
        this.defaultRepository = defaultRepository;
        this.sourceRepositories = sourceRepositories;
        this.writeRepository = writeRepository ?? defaultRepository;
    }
    setResolver(resolver) {
        this.resolver = resolver;
        if (this.defaultRepository &&
            typeof this.defaultRepository.setResolver === "function") {
            this.defaultRepository.setResolver(resolver);
        }
        if (this.sourceRepositories) {
            for (const repo of Object.values(this.sourceRepositories)) {
                if (repo && typeof repo.setResolver === "function") {
                    repo.setResolver(resolver);
                }
            }
        }
        if (this.writeRepository &&
            typeof this.writeRepository.setResolver === "function") {
            this.writeRepository.setResolver(resolver);
        }
    }
    getReadRepositoryForPattern(pattern) {
        if (this.resolver && this.sourceRepositories) {
            for (const [name, rsc] of Object.entries(this.resolver.resolveAll())) {
                if (rsc.pattern === pattern) {
                    const repo = this.sourceRepositories[name];
                    if (repo) {
                        return repo;
                    }
                }
            }
        }
        if (this.defaultRepository) {
            return this.defaultRepository;
        }
        throw new Error(`MultiRepository: no repository found for pattern: ${pattern}`);
    }
    getReadRepositoryForPath(path) {
        if (this.resolver && this.sourceRepositories) {
            for (const { name, pattern } of this.resolver.resolveAll()) {
                if (SourceConfigResolver.patternTest(pattern, path)) {
                    const repo = this.sourceRepositories[name];
                    if (repo) {
                        return repo;
                    }
                    break;
                }
            }
        }
        if (this.defaultRepository) {
            return this.defaultRepository;
        }
        throw new Error(`MultiRepository: no repository found for path: ${path}`);
    }
    async listFiles(pattern) {
        const repo = this.getReadRepositoryForPattern(pattern);
        return repo.listFiles(pattern);
    }
    async readFile(path) {
        const repo = this.getReadRepositoryForPath(path);
        return repo.readFile(path);
    }
    async openFileStream(path) {
        const repo = this.getReadRepositoryForPath(path);
        return repo.openFileStream(path);
    }
    async exists(path) {
        const repo = this.getReadRepositoryForPath(path);
        return repo.exists(path);
    }
    async writeFile(path, data) {
        return this.writeRepository.writeFile(path, data);
    }
    async removeFile(path) {
        return this.writeRepository.removeFile(path);
    }
    async removeDir(path) {
        return this.writeRepository.removeDir(path);
    }
}