@wabot-dev/framework 0.9.1 → 0.9.5

package/dist/src/feature/project-runner/ProjectRunner.js

@@ -0,0 +1,276 @@
+import { readdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { container } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { Locker } from '../../core/lock/Locker.js';
+import '../chat-bot/ChatAdapterRegistry.js';
+import '../chat-bot/ChatBot.js';
+import '../chat-bot/ChatOperator.js';
+import { ChatRepository } from '../chat-bot/ChatRepository.js';
+import '../chat-bot/UnionChatAdapter.js';
+import '../chat-bot/metadata/ChatAdapterMetadataStore.js';
+import 'uuid';
+import '../chat-bot/metadata/ChatBotMetadataStore.js';
+import { runChatAdapters } from '../chat-bot/runChatAdapters.js';
+import '../../core/error/setupErrorHandlers.js';
+import { ControllerMetadataStore } from '../chat-controller/metadata/ControllerMetadataStore.js';
+import '../chat-controller/ChatResolver.js';
+import { runChatControllers } from '../chat-controller/runChatControllers.js';
+import { RestControllerMetadataStore } from '../rest-controller/metadata/RestControllerMetadataStore.js';
+import { runRestControllers } from '../rest-controller/runRestControllers.js';
+import { AsyncMetadataStore } from '../async/AsyncMetadataStore.js';
+import { TransactionMetadataStore } from '../async/TransactionMetadataStore.js';
+import '../async/Async.js';
+import '../../_virtual/index.js';
+import { CronJobRepository } from '../async/CronJobRepository.js';
+import { JobRepository } from '../async/JobRepository.js';
+import '../async/JobRunner.js';
+import { runCommandHandlers } from '../async/runCommandHandlers.js';
+import { runCronHandlers } from '../async/runCronHandlers.js';
+import { SocketControllerMetadataStore } from '../socket-controller/metadata/SocketControllerMetadataStore.js';
+import { runSocketControllers } from '../socket-controller/runSocketControllers.js';
+import { MemoryRepositoryAdapter } from '../repository/MemoryRepositoryAdapter.js';
+import { RepositoryMetadataStore } from '../repository/RepositoryMetadataStore.js';
+import { RepositoryAdapterRegistry } from '../repository/RepositoryAdapterRegistry.js';
+
+const logger = new Logger('wabot:project-runner');
+const TEST_FILE_PATTERNS = /\.(test|spec|unit|integration|e2e|multiprocess)\.(ts|js)$/;
+const DEFAULT_CHAT_ADAPTERS = [
+    ['../../addon/chat-bot/openia', 'OpenaiChatAdapter'],
+    ['../../addon/chat-bot/openrouter', 'OpenRouterChatAdapter'],
+    ['../../addon/chat-bot/anthropic', 'AnthropicChatAdapter'],
+    ['../../addon/chat-bot/google', 'GoogleChatAdapter'],
+];
+class ProjectRunner {
+    directories;
+    chatAdapters;
+    connectionString;
+    isPg;
+    pool = null;
+    constructor(config = {}) {
+        this.directories = config.directories ?? ['src'];
+        this.chatAdapters = config.chatAdapters;
+        this.connectionString = this.resolveConnectionString(config.connectionString);
+        this.isPg = this.connectionString != null && isPostgresUrl(this.connectionString);
+    }
+    async run() {
+        const [, files] = await Promise.all([
+            this.isPg ? this.initPool() : Promise.resolve(),
+            this.scanDirectories(),
+        ]);
+        await this.importFiles(files);
+        const components = this.discoverComponents();
+        await this.registerAdapters(components);
+        await this.startComponents(components);
+    }
+    resolveConnectionString(configValue) {
+        const cs = configValue ?? process.env.DATABASE_URL ?? null;
+        if (cs && !isPostgresUrl(cs)) {
+            logger.warn(`connectionString "${cs}" does not match a known scheme (postgres://, postgresql://); falling back to in-memory adapters`);
+        }
+        return cs;
+    }
+    async initPool() {
+        const { Pool } = await import('pg');
+        this.pool = new Pool({ connectionString: this.connectionString });
+        container.registerInstance(Pool, this.pool);
+    }
+    async scanDirectories() {
+        const seen = new Set();
+        const roots = this.directories
+            .map((d) => resolve(d))
+            .filter((d) => {
+            if (seen.has(d))
+                return false;
+            seen.add(d);
+            return true;
+        });
+        const results = await Promise.all(roots.map((dir) => scanDir(dir).catch((err) => {
+            logger.warn(`Could not read directory ${dir}: ${err.message}`);
+            return [];
+        })));
+        return results.flat();
+    }
+    async importFiles(files) {
+        if (files.length === 0) {
+            logger.info('No files to import');
+            return;
+        }
+        const results = await Promise.allSettled(files.map((file) => import(pathToFileURL(file).href)));
+        let imported = 0;
+        let failed = 0;
+        const errorGroups = new Map();
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.status === 'fulfilled') {
+                imported++;
+            }
+            else {
+                failed++;
+                const message = result.reason.message;
+                const group = errorGroups.get(message);
+                if (group) {
+                    group.push(files[i]);
+                }
+                else {
+                    errorGroups.set(message, [files[i]]);
+                }
+            }
+        }
+        for (const [message, affected] of errorGroups) {
+            const [first, ...rest] = affected;
+            const suffix = rest.length > 0 ? ` (also affects ${rest.length} more file(s))` : '';
+            logger.error(`Failed to import ${first}: ${message}${suffix}`);
+        }
+        if (failed > 0) {
+            logger.warn(`Imported ${imported}/${files.length} files (${failed} failed)`);
+        }
+        else {
+            logger.info(`Imported ${imported}/${files.length} files`);
+        }
+    }
+    discoverComponents() {
+        const asyncStore = container.resolve(AsyncMetadataStore);
+        return {
+            chatControllers: container
+                .resolve(ControllerMetadataStore)
+                .getAllChatControllerConstructors(),
+            restControllers: container
+                .resolve(RestControllerMetadataStore)
+                .getAllRestControllerConstructors(),
+            commandHandlers: asyncStore.getAllCommandHandlers(),
+            cronHandlers: asyncStore.getAllCronHandlers(),
+            socketControllers: container
+                .resolve(SocketControllerMetadataStore)
+                .getAllSocketControllerConstructors(),
+        };
+    }
+    registerAdapters(components) {
+        return this.isPg
+            ? this.registerPostgresAdapters(components)
+            : this.registerMemoryAdapters(components);
+    }
+    async registerMemoryAdapters(components) {
+        const needsJobs = components.commandHandlers.length > 0 || components.cronHandlers.length > 0;
+        const [chatBotMod, lockMod, asyncMod] = await Promise.all([
+            import('../../addon/chat-bot/in-memory/index.js'),
+            import('../../addon/lock/index.js'),
+            needsJobs ? import('../../addon/async/in-memory/index.js') : Promise.resolve(null),
+        ]);
+        container.register(ChatRepository, { useToken: chatBotMod.InMemoryChatRepository });
+        container.register(Locker, { useToken: lockMod.InMemoryLocker });
+        const memoryAdapter = new MemoryRepositoryAdapter();
+        container.resolve(RepositoryAdapterRegistry).setDefault(memoryAdapter);
+        container.resolve(RepositoryMetadataStore).validateExtensionsRegistered(memoryAdapter.id);
+        if (asyncMod) {
+            container.register(JobRepository, { useToken: asyncMod.InMemoryJobRepository });
+            if (components.cronHandlers.length > 0) {
+                container.register(CronJobRepository, {
+                    useToken: asyncMod.InMemoryCronJobRepository,
+                });
+            }
+        }
+        logger.info('Configured with in-memory adapters');
+    }
+    async registerPostgresAdapters(components) {
+        if (!this.pool) {
+            throw new Error('Postgres pool was not initialized');
+        }
+        const [chatBotMod, pgMod, asyncMod] = await Promise.all([
+            import('../../addon/chat-bot/pg/index.js'),
+            import('../pg/index.js'),
+            import('../../addon/async/pg/index.js'),
+        ]);
+        container.register(ChatRepository, { useToken: chatBotMod.PgChatRepository });
+        container.register(Locker, { useToken: pgMod.PgLocker });
+        const pgAdapter = new pgMod.PgJsonRepositoryAdapter(this.pool);
+        container.resolve(RepositoryAdapterRegistry).setDefault(pgAdapter);
+        container.resolve(RepositoryMetadataStore).validateExtensionsRegistered(pgAdapter.id);
+        const transactionStore = container.resolve(TransactionMetadataStore);
+        transactionStore.registerAdapter('default', new asyncMod.PgTransactionAdapter(this.pool));
+        const hasCommandHandlers = components.commandHandlers.length > 0;
+        const hasCronHandlers = components.cronHandlers.length > 0;
+        if (hasCommandHandlers || hasCronHandlers) {
+            container.register(JobRepository, { useToken: asyncMod.PgJobRepository });
+        }
+        if (hasCronHandlers) {
+            container.register(CronJobRepository, { useToken: asyncMod.PgCronJobRepository });
+        }
+        logger.info('Configured with PostgreSQL adapters');
+    }
+    async startComponents(components) {
+        const chatAdapters = this.chatAdapters ?? (await this.resolveDefaultChatAdapters());
+        if (chatAdapters.length > 0) {
+            runChatAdapters(chatAdapters);
+        }
+        if (components.chatControllers.length > 0) {
+            logger.info(`Starting ${components.chatControllers.length} chat controller(s)`);
+            runChatControllers(components.chatControllers);
+        }
+        if (components.restControllers.length > 0) {
+            logger.info(`Starting ${components.restControllers.length} REST controller(s)`);
+            runRestControllers(components.restControllers);
+        }
+        if (components.commandHandlers.length > 0) {
+            logger.info(`Starting ${components.commandHandlers.length} command handler(s)`);
+            runCommandHandlers(components.commandHandlers);
+        }
+        if (components.cronHandlers.length > 0) {
+            logger.info(`Starting ${components.cronHandlers.length} cron handler(s)`);
+            runCronHandlers(components.cronHandlers);
+        }
+        if (components.socketControllers.length > 0) {
+            logger.info(`Starting ${components.socketControllers.length} socket controller(s)`);
+            runSocketControllers(components.socketControllers);
+        }
+    }
+    async resolveDefaultChatAdapters() {
+        const results = await Promise.all(DEFAULT_CHAT_ADAPTERS.map(async ([path, name]) => {
+            try {
+                const mod = await import(path);
+                const adapter = mod[name];
+                if (!adapter) {
+                    logger.warn(`Skipping ${name}: module loaded but no '${name}' export found`);
+                    return null;
+                }
+                return adapter;
+            }
+            catch {
+                logger.warn(`Skipping ${name}: missing peer dependency`);
+                return null;
+            }
+        }));
+        return results.filter((a) => a != null);
+    }
+}
+function run(config) {
+    return new ProjectRunner(config).run();
+}
+function isPostgresUrl(cs) {
+    return cs.startsWith('postgres://') || cs.startsWith('postgresql://');
+}
+async function scanDir(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const subResults = await Promise.all(entries.map(async (entry) => {
+        const name = entry.name;
+        if (entry.isDirectory()) {
+            if (name.startsWith('__'))
+                return [];
+            return scanDir(join(dir, name));
+        }
+        if (!entry.isFile())
+            return [];
+        if (!(name.endsWith('.ts') || name.endsWith('.js')))
+            return [];
+        if (name.endsWith('.d.ts'))
+            return [];
+        const fullPath = join(dir, name);
+        if (TEST_FILE_PATTERNS.test(fullPath))
+            return [];
+        return [fullPath];
+    }));
+    return subResults.flat();
+}
+
+export { ProjectRunner, run };

package/dist/src/feature/repository/@memoryExtension.js

@@ -0,0 +1,29 @@
+import { container } from '../../core/injection/index.js';
+import { MEMORY_ADAPTER_ID, MemoryRepositoryExtension } from './MemoryRepositoryAdapter.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+function inheritsFrom(ctor, base) {
+    let proto = ctor.prototype;
+    while (proto) {
+        if (proto === base.prototype)
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
+function memoryExtension(repositoryClass) {
+    if (typeof repositoryClass !== 'function') {
+        throw new Error(`@memoryExtension: repository argument must be a class, ` +
+            `got ${typeof repositoryClass}`);
+    }
+    return function (target) {
+        if (!inheritsFrom(target, MemoryRepositoryExtension)) {
+            throw new Error(`@memoryExtension on ${target.name}: extension class must extend ` +
+                `MemoryRepositoryExtension.`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveExtension(repositoryClass, MEMORY_ADAPTER_ID, target);
+    };
+}
+
+export { memoryExtension };

package/dist/src/feature/repository/@query.js

@@ -0,0 +1,22 @@
+import { container } from '../../core/injection/index.js';
+import { parseQueryMethodName } from './parseQueryMethodName.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+function query() {
+    return function (target, propertyKey, descriptor) {
+        const functionName = propertyKey.toString();
+        const ctor = target.constructor;
+        parseQueryMethodName(functionName);
+        const value = descriptor ? descriptor.value : target[propertyKey];
+        if (value !== undefined && typeof value !== 'function') {
+            throw new Error(`@query() on ${ctor.name}.${functionName}: decorated property must be a function`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveQueryMethodMetadata({
+            repositoryConstructor: ctor,
+            functionName,
+        });
+    };
+}
+
+export { query };

package/dist/src/feature/repository/@queryExtension.js

@@ -0,0 +1,21 @@
+import { container } from '../../core/injection/index.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+function queryExtension() {
+    return function (target, propertyKey, descriptor) {
+        const functionName = propertyKey.toString();
+        const ctor = target.constructor;
+        const value = descriptor ? descriptor.value : target[propertyKey];
+        if (value !== undefined && typeof value !== 'function') {
+            throw new Error(`@queryExtension() on ${ctor.name}.${functionName}: ` +
+                `decorated property must be a function (typically a declare).`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveExtensionMethodMetadata({
+            repositoryConstructor: ctor,
+            functionName,
+        });
+    };
+}
+
+export { queryExtension };

package/dist/src/feature/repository/@repository.js

@@ -0,0 +1,170 @@
+import { container, singleton } from '../../core/injection/index.js';
+import { parseQueryMethodName } from './parseQueryMethodName.js';
+import { RepositoryAdapterRegistry } from './RepositoryAdapterRegistry.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+const RUNTIME_KEY = Symbol('wabot:repositoryRuntime');
+const EXTENSION_KEY = Symbol('wabot:repositoryExtension');
+const AST_CACHE_KEY = Symbol('wabot:repositoryAstCache');
+function getConfig(self) {
+    const ctor = self.constructor;
+    const config = container.resolve(RepositoryMetadataStore).getRepositoryConfig(ctor);
+    if (!config) {
+        throw new Error(`${ctor.name} must be decorated with @repository`);
+    }
+    return config;
+}
+function getRuntime(self) {
+    let runtime = self[RUNTIME_KEY];
+    if (runtime)
+        return runtime;
+    const config = getConfig(self);
+    const adapter = container.resolve(RepositoryAdapterRegistry).getDefault();
+    runtime = adapter.build(config);
+    Object.defineProperty(self, RUNTIME_KEY, { value: runtime, enumerable: false });
+    return runtime;
+}
+function getExtension(self) {
+    const cached = self[EXTENSION_KEY];
+    if (cached !== undefined)
+        return cached;
+    const ctor = self.constructor;
+    const adapter = container.resolve(RepositoryAdapterRegistry).getDefault();
+    const store = container.resolve(RepositoryMetadataStore);
+    const ExtensionCtor = store.getExtension(ctor, adapter.id);
+    if (!ExtensionCtor) {
+        throw new Error(`${ctor.name}.extension is not available: no extension registered ` +
+            `for adapter "${adapter.id.description ?? 'unknown'}". ` +
+            `Import the extension class so its @<adapter>Extension decorator runs, ` +
+            `or check the active adapter.`);
+    }
+    if (typeof adapter.buildExtension !== 'function') {
+        throw new Error(`${ctor.name}.extension cannot be built: adapter ` +
+            `"${adapter.id.description ?? 'unknown'}" does not implement buildExtension().`);
+    }
+    const config = getConfig(self);
+    const ext = adapter.buildExtension(config, ExtensionCtor);
+    Object.defineProperty(self, EXTENSION_KEY, { value: ext, enumerable: false });
+    return ext;
+}
+function installExtensionAccessor(target) {
+    const proto = target.prototype;
+    if (Object.getOwnPropertyDescriptor(proto, 'extension'))
+        return;
+    Object.defineProperty(proto, 'extension', {
+        get() {
+            return getExtension(this);
+        },
+        configurable: true,
+        enumerable: false,
+    });
+}
+function getAst(self, methodName) {
+    let cache = self[AST_CACHE_KEY];
+    if (!cache) {
+        cache = new Map();
+        Object.defineProperty(self, AST_CACHE_KEY, { value: cache, enumerable: false });
+    }
+    let ast = cache.get(methodName);
+    if (!ast) {
+        ast = parseQueryMethodName(methodName);
+        cache.set(methodName, ast);
+    }
+    return ast;
+}
+function makeExtensionImpl(methodName) {
+    return function (...args) {
+        const ext = getExtension(this);
+        const fn = ext[methodName];
+        if (typeof fn !== 'function') {
+            throw new Error(`${this.constructor.name}.${methodName}: ` +
+                `the active adapter's extension does not implement this method.`);
+        }
+        return fn.apply(ext, args);
+    };
+}
+function makeQueryImpl(methodName) {
+    return async function (...args) {
+        const ast = getAst(this, methodName);
+        const runtime = getRuntime(this);
+        switch (ast.prefix) {
+            case 'find':
+                return runtime.runQuery(ast, args);
+            case 'findOne': {
+                const rows = await runtime.runQuery(ast, args);
+                return rows[0] ?? null;
+            }
+            case 'count':
+                return runtime.runCount(ast, args);
+            case 'exists':
+                return runtime.runExists(ast, args);
+            case 'delete':
+                return runtime.runDelete(ast, args);
+        }
+    };
+}
+const CRUD_METHODS = {
+    async find(id) {
+        return getRuntime(this).find(id);
+    },
+    async findOrThrow(id) {
+        return getRuntime(this).findOrThrow(id);
+    },
+    async findByIds(ids) {
+        return getRuntime(this).findByIds(ids);
+    },
+    async findAll() {
+        return getRuntime(this).findAll();
+    },
+    async create(item) {
+        return getRuntime(this).create(item);
+    },
+    async update(item) {
+        return getRuntime(this).update(item);
+    },
+    async delete(item) {
+        return getRuntime(this).delete(item);
+    },
+};
+function installCrudMethods(target) {
+    const proto = target.prototype;
+    for (const [name, fn] of Object.entries(CRUD_METHODS)) {
+        if (Object.prototype.hasOwnProperty.call(proto, name)) {
+            const existing = proto[name];
+            if (typeof existing === 'function')
+                continue;
+        }
+        Object.defineProperty(proto, name, { value: fn, writable: true, configurable: true });
+    }
+}
+function repository(config) {
+    return function (target) {
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveRepositoryConfig(target, config);
+        installCrudMethods(target);
+        installExtensionAccessor(target);
+        const queryMethods = store.getQueryMethods(target);
+        for (const meta of queryMethods) {
+            if (Object.prototype.hasOwnProperty.call(target.prototype, meta.functionName)) {
+                const existing = target.prototype[meta.functionName];
+                if (typeof existing === 'function' && existing.length > 0) {
+                    continue;
+                }
+            }
+            target.prototype[meta.functionName] = makeQueryImpl(meta.functionName);
+        }
+        const extensionMethods = store.getExtensionMethods(target);
+        for (const meta of extensionMethods) {
+            if (Object.prototype.hasOwnProperty.call(target.prototype, meta.functionName)) {
+                const existing = target.prototype[meta.functionName];
+                if (typeof existing === 'function' && existing.length > 0) {
+                    continue;
+                }
+            }
+            target.prototype[meta.functionName] = makeExtensionImpl(meta.functionName);
+        }
+        singleton()(target);
+    };
+}
+
+export { repository };

package/dist/src/feature/repository/MemoryRepositoryAdapter.js

@@ -0,0 +1,110 @@
+import { generate } from 'short-uuid';
+import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
+import { evaluateQueryAst } from './evaluateQueryAst.js';
+
+function cloneEntity(config, item) {
+    const data = JSON.parse(JSON.stringify(item['data']));
+    return new config.constructor(data);
+}
+class MemoryRepositoryExtension {
+    items;
+    config;
+    constructor(items, config) {
+        this.items = items;
+        this.config = config;
+    }
+    clone(item) {
+        return cloneEntity(this.config, item);
+    }
+}
+class MemoryRepositoryRuntime {
+    items;
+    config;
+    constructor(items, config) {
+        this.items = items;
+        this.config = config;
+    }
+    async find(id) {
+        const item = this.items.get(id);
+        return item ? cloneEntity(this.config, item) : null;
+    }
+    async findOrThrow(id) {
+        const item = await this.find(id);
+        if (!item) {
+            throw new CustomError({
+                message: `Not found ${this.config.constructor.name} with id = '${id}'`,
+                httpCode: 404,
+            });
+        }
+        return item;
+    }
+    async findByIds(ids) {
+        const out = [];
+        for (const id of ids) {
+            const item = this.items.get(id);
+            if (item)
+                out.push(cloneEntity(this.config, item));
+        }
+        return out;
+    }
+    async findAll() {
+        return [...this.items.values()].map((i) => cloneEntity(this.config, i));
+    }
+    async create(item) {
+        if (item.wasCreated()) {
+            throw new Error('Item already created');
+        }
+        item['data'].id = generate();
+        item['data'].createdAt = new Date().getTime();
+        item.validate();
+        this.items.set(item.id, cloneEntity(this.config, item));
+    }
+    async update(item) {
+        item.validate();
+        if (!this.items.has(item.id)) {
+            throw new Error(`Update failed: no affected rows`);
+        }
+        this.items.set(item.id, cloneEntity(this.config, item));
+    }
+    async delete(item) {
+        this.items.delete(item.id);
+    }
+    async runQuery(ast, args) {
+        const result = evaluateQueryAst(this.items.values(), ast, args);
+        return result.map((i) => cloneEntity(this.config, i));
+    }
+    async runCount(ast, args) {
+        return evaluateQueryAst(this.items.values(), ast, args).length;
+    }
+    async runExists(ast, args) {
+        return evaluateQueryAst(this.items.values(), ast, args).length > 0;
+    }
+    async runDelete(ast, args) {
+        const matched = evaluateQueryAst(this.items.values(), ast, args);
+        for (const item of matched) {
+            this.items.delete(item.id);
+        }
+    }
+}
+const MEMORY_ADAPTER_ID = Symbol('wabot:memory-adapter');
+class MemoryRepositoryAdapter {
+    id = MEMORY_ADAPTER_ID;
+    stores = new Map();
+    getStore(config) {
+        let store = this.stores.get(config);
+        if (!store) {
+            store = new Map();
+            this.stores.set(config, store);
+        }
+        return store;
+    }
+    build(config) {
+        return new MemoryRepositoryRuntime(this.getStore(config), config);
+    }
+    buildExtension(config, ExtensionCtor) {
+        return new ExtensionCtor(this.getStore(config), config);
+    }
+}
+
+export { MEMORY_ADAPTER_ID, MemoryRepositoryAdapter, MemoryRepositoryExtension };

package/dist/src/feature/repository/RepositoryAdapterRegistry.js

@@ -0,0 +1,27 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let RepositoryAdapterRegistry = class RepositoryAdapterRegistry {
+    adapter = null;
+    setDefault(adapter) {
+        this.adapter = adapter;
+    }
+    getDefault() {
+        if (!this.adapter) {
+            throw new Error('No repository adapter registered. ' +
+                'Register one with container.resolve(RepositoryAdapterRegistry).setDefault(adapter).');
+        }
+        return this.adapter;
+    }
+    hasDefault() {
+        return this.adapter !== null;
+    }
+    clear() {
+        this.adapter = null;
+    }
+};
+RepositoryAdapterRegistry = __decorate([
+    singleton()
+], RepositoryAdapterRegistry);
+
+export { RepositoryAdapterRegistry };