@wabot-dev/framework 0.8.3 → 0.9.0

package/dist/src/addon/chat-bot/wabot/WabotChatAdapter.js

@@ -4,6 +4,14 @@ import { CustomError } from '../../../core/error/CustomError.js';
 import '../../../core/error/setupErrorHandlers.js';
 import { singleton } from '../../../core/injection/index.js';
 import { Logger } from '../../../core/logger/Logger.js';
+import '../../../feature/chat-bot/ChatAdapterRegistry.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import '../../../feature/chat-bot/ChatOperator.js';
+import '../../../feature/chat-bot/UnionChatAdapter.js';
+import { chatAdapter } from '../../../feature/chat-bot/metadata/@chatAdapter.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 
 let WabotChatAdapter = class WabotChatAdapter {
     apiKey;
@@ -35,6 +43,7 @@ let WabotChatAdapter = class WabotChatAdapter {
     }
 };
 WabotChatAdapter = __decorate([
+    chatAdapter({ provider: 'wabot' }),
     singleton(),
     __metadata("design:paramtypes", [Env])
 ], WabotChatAdapter);

package/dist/src/addon/chat-controller/cmd/CmdChannel.js

@@ -2,9 +2,9 @@ import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 import { Logger } from '../../../core/logger/Logger.js';
 import { cmdChannelName } from './cmdChannelName.js';
-import * as readline from 'readline';
-import * as fs from 'fs';
-import * as path from 'path';
+import * as readline from 'node:readline';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { Random } from '../../../core/random/Random.js';
 import { Auth } from '../../../core/auth/Auth.js';
 

package/dist/src/addon/chat-controller/wasender/WasenderWebhookController.js

@@ -4,7 +4,7 @@ import '../../../core/injection/index.js';
 import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
 import { onPost } from '../../../feature/rest-controller/metadata/@onPost.js';
 import { extractNumberFromWasenderMessageKey } from './extractNumberFromWasenderKey.js';
-import { IncomingMessage } from 'http';
+import { IncomingMessage } from 'node:http';
 
 class WasenderWebhookController {
     wasender;

package/dist/src/addon/chat-controller/whatsapp/PgWhatsAppRepository.js

@@ -8,6 +8,8 @@ import 'debug';
 import 'node:crypto';
 import '../../../feature/pg/withPgClient.js';
 import '../../../feature/pg/pgStorage.js';
+import '../../../feature/pg/query/PgJsonRepository.js';
+import '../../../feature/pg/query/PgRepositoryMetadataStore.js';
 
 let PgWhatsAppRepository = class PgWhatsAppRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/addon/chat-controller/whatsapp/WhatsAppSender.js

@@ -1,7 +1,10 @@
+import '../../../feature/chat-bot/ChatAdapterRegistry.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
 import '../../../feature/chat-bot/ChatOperator.js';
+import '../../../feature/chat-bot/UnionChatAdapter.js';
 import '../../../core/injection/index.js';
+import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../core/error/setupErrorHandlers.js';

package/dist/src/addon/chat-controller/whatsapp/cloud-api/WhatsAppSenderByCloudApi.js

@@ -5,9 +5,12 @@ import { singleton } from '../../../../core/injection/index.js';
 import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
 import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
 import '../../../../feature/chat-controller/runChatControllers.js';
+import '../../../../feature/chat-bot/ChatAdapterRegistry.js';
 import '../../../../feature/chat-bot/ChatBot.js';
 import '../../../../feature/chat-bot/ChatOperator.js';
 import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
+import '../../../../feature/chat-bot/UnionChatAdapter.js';
+import '../../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 import 'uuid';
 import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../../core/error/setupErrorHandlers.js';

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppSenderByWabotProxy.js

@@ -2,9 +2,12 @@ import { __decorate, __metadata } from 'tslib';
 import { WhatsAppSender } from '../WhatsAppSender.js';
 import { singleton } from '../../../../core/injection/index.js';
 import { Logger } from '../../../../core/logger/Logger.js';
+import '../../../../feature/chat-bot/ChatAdapterRegistry.js';
 import '../../../../feature/chat-bot/ChatBot.js';
 import '../../../../feature/chat-bot/ChatOperator.js';
 import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
+import '../../../../feature/chat-bot/UnionChatAdapter.js';
+import '../../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 import 'uuid';
 import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../../core/error/setupErrorHandlers.js';

package/dist/src/feature/chat-bot/Chat.js

@@ -41,7 +41,8 @@ class Chat extends Entity {
         this.data.connections.splice(index, 1);
     }
     hasAssociation(association) {
-        return this.data.associations?.some((a) => a.type === association.type && a.id === association.id) ?? false;
+        return (this.data.associations?.some((a) => a.type === association.type && a.id === association.id) ??
+            false);
     }
     hasAssociations(type) {
         return this.data.associations?.some((a) => a.type === type) ?? false;

package/dist/src/feature/chat-bot/ChatAdapterRegistry.js

@@ -0,0 +1,26 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let ChatAdapterRegistry = class ChatAdapterRegistry {
+    adapters = new Map();
+    order = [];
+    register(provider, adapter) {
+        if (!this.adapters.has(provider))
+            this.order.push(provider);
+        this.adapters.set(provider, adapter);
+    }
+    get(provider) {
+        return this.adapters.get(provider);
+    }
+    defaultProvider() {
+        return this.order[0];
+    }
+    size() {
+        return this.adapters.size;
+    }
+};
+ChatAdapterRegistry = __decorate([
+    singleton()
+], ChatAdapterRegistry);
+
+export { ChatAdapterRegistry };

package/dist/src/feature/chat-bot/ChatBot.js

@@ -35,14 +35,17 @@ let ChatBot = class ChatBot {
         const systemPrompt = await this.mindset.systemPrompt();
         const tools = this.mindset.tools();
         const identity = await this.mindset.identity();
-        const llms = await this.mindset.llms();
-        if (llms.length === 0) {
-            throw new Error(`Invalid ${this.mindset.constructor.name} - llms not found`);
+        const needsVision = prevItems.some((item) => {
+            const data = item.getData();
+            return data.type === 'humanMessage' && (data.humanMessage.images?.length ?? 0) > 0;
+        });
+        const kind = needsVision ? 'visionLlm' : 'llm';
+        const candidates = await this.mindset.resolveModels(kind);
+        if (candidates.length === 0) {
+            throw new Error(`Invalid ${this.mindset.constructor.name} - no model resolved for kind '${kind}'`);
         }
-        const llm = llms[0];
         const { nextItems: newItemsData } = await this.adapter.nextItems({
-            model: llm.model,
-            provider: llm.provider,
+            models: candidates,
             systemPrompt,
             tools,
             prevItems: prevItems.map((x) => x.getData()),

package/dist/src/feature/chat-bot/UnionChatAdapter.js

@@ -0,0 +1,64 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { ChatAdapterRegistry } from './ChatAdapterRegistry.js';
+import { isRetryableError } from './isRetryableError.js';
+
+let UnionChatAdapter = class UnionChatAdapter {
+    registry;
+    logger = new Logger('wabot:union-chat-adapter');
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async nextItems(req) {
+        if (this.registry.size() === 0) {
+            throw new Error('No chat adapters registered. Call runChatAdapters([...]) before sending messages.');
+        }
+        if (req.models.length === 0) {
+            throw new Error('UnionChatAdapter received empty models list');
+        }
+        const groups = this.groupByProvider(req.models);
+        let lastError;
+        for (const group of groups) {
+            const adapter = this.registry.get(group.provider);
+            if (!adapter) {
+                this.logger.warn(`No adapter registered for provider '${group.provider}', skipping group`);
+                continue;
+            }
+            try {
+                return await adapter.nextItems({ ...req, models: group.entries });
+            }
+            catch (err) {
+                if (!isRetryableError(err)) {
+                    throw err;
+                }
+                this.logger.warn(`Adapter for provider '${group.provider}' failed with retryable error, trying next group`, err instanceof Error ? { message: err.message } : { err });
+                lastError = err;
+            }
+        }
+        throw lastError ?? new Error('No adapter could handle the request');
+    }
+    groupByProvider(models) {
+        const fallbackProvider = this.registry.defaultProvider();
+        const groups = [];
+        for (const ref of models) {
+            const provider = ref.provider ?? fallbackProvider;
+            if (!provider)
+                continue;
+            const last = groups[groups.length - 1];
+            if (last && last.provider === provider) {
+                last.entries.push(ref);
+            }
+            else {
+                groups.push({ provider, entries: [ref] });
+            }
+        }
+        return groups;
+    }
+};
+UnionChatAdapter = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [ChatAdapterRegistry])
+], UnionChatAdapter);
+
+export { UnionChatAdapter };

package/dist/src/feature/chat-bot/isChatMessageEmpty.js

@@ -1,5 +1,5 @@
 function isChatMessageEmpty(message) {
-    return (!message.text && !message.images?.length && !message.documents?.length && !message.object);
+    return !message.text && !message.images?.length && !message.documents?.length && !message.object;
 }
 
 export { isChatMessageEmpty };

package/dist/src/feature/chat-bot/isRetryableError.js

@@ -0,0 +1,63 @@
+/**
+ * Returns true when an error from a chat adapter is worth retrying with another
+ * model or another adapter (transient/availability issues), false when retrying
+ * would just propagate the same configuration problem (auth, validation).
+ */
+function isRetryableError(err) {
+    if (!err || typeof err !== 'object')
+        return true;
+    const status = readStatus(err);
+    if (status !== undefined) {
+        if (status === 408 || status === 425 || status === 429)
+            return true;
+        if (status >= 500)
+            return true;
+        if (status >= 400 && status < 500)
+            return false;
+        return false;
+    }
+    const code = readCode(err);
+    if (code) {
+        const transient = new Set([
+            'ECONNRESET',
+            'ECONNABORTED',
+            'ECONNREFUSED',
+            'ETIMEDOUT',
+            'EAI_AGAIN',
+            'ENETUNREACH',
+            'ENOTFOUND',
+            'EPIPE',
+            'UND_ERR_CONNECT_TIMEOUT',
+            'UND_ERR_HEADERS_TIMEOUT',
+            'UND_ERR_BODY_TIMEOUT',
+            'UND_ERR_SOCKET',
+        ]);
+        if (transient.has(code))
+            return true;
+        return false;
+    }
+    if (err instanceof Error) {
+        const name = err.name;
+        if (name === 'AbortError' || name === 'TimeoutError' || name === 'FetchError')
+            return true;
+    }
+    return true;
+}
+function readStatus(err) {
+    const candidates = [
+        err.status,
+        err.statusCode,
+        err.response?.status,
+    ];
+    for (const c of candidates) {
+        if (typeof c === 'number')
+            return c;
+    }
+    return undefined;
+}
+function readCode(err) {
+    const c = err.code;
+    return typeof c === 'string' ? c : undefined;
+}
+
+export { isRetryableError };

package/dist/src/feature/chat-bot/metadata/@chatAdapter.js

@@ -0,0 +1,11 @@
+import { container } from '../../../core/injection/index.js';
+import { ChatAdapterMetadataStore } from './ChatAdapterMetadataStore.js';
+
+function chatAdapter(config) {
+    return function (target) {
+        const store = container.resolve(ChatAdapterMetadataStore);
+        store.save({ constructor: target, provider: config.provider });
+    };
+}
+
+export { chatAdapter };

package/dist/src/feature/chat-bot/metadata/ChatAdapterMetadataStore.js

@@ -0,0 +1,17 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+
+let ChatAdapterMetadataStore = class ChatAdapterMetadataStore {
+    adapters = new Map();
+    save(metadata) {
+        this.adapters.set(metadata.constructor, metadata);
+    }
+    get(ctor) {
+        return this.adapters.get(ctor);
+    }
+};
+ChatAdapterMetadataStore = __decorate([
+    singleton()
+], ChatAdapterMetadataStore);
+
+export { ChatAdapterMetadataStore };

package/dist/src/feature/chat-bot/runChatAdapters.js

@@ -0,0 +1,22 @@
+import { container } from '../../core/injection/index.js';
+import { ChatAdapter } from './ChatAdapter.js';
+import { ChatAdapterRegistry } from './ChatAdapterRegistry.js';
+import { UnionChatAdapter } from './UnionChatAdapter.js';
+import { ChatAdapterMetadataStore } from './metadata/ChatAdapterMetadataStore.js';
+import 'uuid';
+import './metadata/ChatBotMetadataStore.js';
+
+function runChatAdapters(adapters) {
+    const store = container.resolve(ChatAdapterMetadataStore);
+    const registry = container.resolve(ChatAdapterRegistry);
+    for (const ctor of adapters) {
+        const meta = store.get(ctor);
+        if (!meta) {
+            throw new Error(`${ctor.name} is missing the @chatAdapter({ provider }) decorator and cannot be registered`);
+        }
+        registry.register(meta.provider, container.resolve(ctor));
+    }
+    container.register(ChatAdapter, { useToken: UnionChatAdapter });
+}
+
+export { runChatAdapters };

package/dist/src/feature/chat-controller/ChatResolver.js

@@ -1,9 +1,12 @@
 import { __decorate, __metadata } from 'tslib';
 import { Chat } from '../chat-bot/Chat.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 { injectable } from '../../core/injection/index.js';
+import '../chat-bot/metadata/ChatAdapterMetadataStore.js';
 import 'uuid';
 import '../chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../core/error/setupErrorHandlers.js';

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -2,10 +2,13 @@ import { Auth } from '../../core/auth/Auth.js';
 import { container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
 import { Chat } from '../chat-bot/Chat.js';
+import '../chat-bot/ChatAdapterRegistry.js';
 import { ChatBot } from '../chat-bot/ChatBot.js';
 import { ChatMemory } from '../chat-bot/ChatMemory.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 { ChatBotMetadataStore } from '../chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../core/error/setupErrorHandlers.js';

package/dist/src/feature/http/HttpServerProvider.js

@@ -1,7 +1,7 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
-import { Server } from 'http';
+import { Server } from 'node:http';
 
 let HttpServerProvider = class HttpServerProvider {
     server = null;

package/dist/src/feature/mindset/IMindset.js

@@ -14,6 +14,10 @@ class Mindset {
     workflow() {
         throw new Error('Method not implemented.');
     }
+    models() {
+        throw new Error('Method not implemented.');
+    }
+    /** @deprecated implement {@link Mindset.models} instead */
     llms() {
         throw new Error('Method not implemented.');
     }

package/dist/src/feature/mindset/MindsetOperator.js

@@ -9,6 +9,10 @@ import '../../core/error/setupErrorHandlers.js';
 import { Logger } from '../../core/logger/Logger.js';
 import { Container } from '../../core/injection/Container.js';
 
+const MODEL_KIND_FALLBACK = {
+    visionLlm: 'llm',
+    audioLlm: 'llm',
+};
 let MindsetOperator = class MindsetOperator {
     mindset;
     container;
@@ -34,8 +38,32 @@ let MindsetOperator = class MindsetOperator {
     workflow() {
         return this.mindset.workflow();
     }
-    llms() {
-        return this.mindset.llms();
+    /** @deprecated use {@link MindsetOperator.models} */
+    async llms() {
+        if (this.mindset.llms)
+            return this.mindset.llms();
+        const models = await this.models();
+        return models.llm ?? [];
+    }
+    async models() {
+        if (this.mindset.models)
+            return this.mindset.models();
+        if (this.mindset.llms)
+            return { llm: await this.mindset.llms() };
+        throw new Error(`Invalid ${this.mindset.constructor.name} - models() or llms() must be implemented`);
+    }
+    async resolveModels(kind) {
+        const models = await this.models();
+        const direct = models[kind];
+        if (direct && direct.length > 0)
+            return direct;
+        const fallbackKind = MODEL_KIND_FALLBACK[kind];
+        if (fallbackKind) {
+            const fallback = models[fallbackKind];
+            if (fallback && fallback.length > 0)
+                return fallback;
+        }
+        return [];
     }
     async systemPrompt() {
         let [context, identity, skills, limits, workflow] = await Promise.all([

package/dist/src/feature/pg/pgStorage.js

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from 'async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks';
 
 const pgStorage = new AsyncLocalStorage();
 /**

package/dist/src/feature/pg/query/@pgJsonRepository.js

@@ -0,0 +1,73 @@
+import { container, singleton } from '../../../core/injection/index.js';
+import { withPgClient } from '../withPgClient.js';
+import { buildQuerySql } from './buildQuerySql.js';
+import { parseQueryMethodName } from './parseQueryMethodName.js';
+import { PgJsonRepository } from './PgJsonRepository.js';
+import { PgRepositoryMetadataStore } from './PgRepositoryMetadataStore.js';
+
+const QUERY_CACHE_KEY = Symbol('wabot:pgQueryCache');
+function makeQueryImpl(methodName, ast) {
+    return async function (...args) {
+        let cache = this[QUERY_CACHE_KEY];
+        if (!cache) {
+            cache = new Map();
+            Object.defineProperty(this, QUERY_CACHE_KEY, { value: cache, enumerable: false });
+        }
+        let built = cache.get(methodName);
+        if (!built) {
+            built = buildQuerySql(ast, this.table, this.columns);
+            cache.set(methodName, built);
+        }
+        const params = built.buildParams(args);
+        switch (ast.prefix) {
+            case 'find': {
+                return await this.query(built.sql, params);
+            }
+            case 'findOne': {
+                const items = await this.query(built.sql, params);
+                return items[0] ?? null;
+            }
+            case 'count': {
+                return await withPgClient(this.pool, async (client) => {
+                    await this.ensureTable(client);
+                    const result = await client.query(built.sql, params);
+                    return result.rows[0]?.count ?? 0;
+                });
+            }
+            case 'exists': {
+                return await withPgClient(this.pool, async (client) => {
+                    await this.ensureTable(client);
+                    const result = await client.query(built.sql, params);
+                    return Boolean(result.rows[0]?.exists);
+                });
+            }
+            case 'delete': {
+                await this.exec(built.sql, params);
+                return;
+            }
+        }
+    };
+}
+function pgJsonRepository(config) {
+    return function (target) {
+        if (target !== PgJsonRepository && !(target.prototype instanceof PgJsonRepository)) {
+            throw new Error(`@pgJsonRepository: ${target.name} must extend PgJsonRepository`);
+        }
+        const store = container.resolve(PgRepositoryMetadataStore);
+        store.saveRepositoryConfig(target, config);
+        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') {
+                    continue;
+                }
+            }
+            const ast = parseQueryMethodName(meta.functionName);
+            target.prototype[meta.functionName] = makeQueryImpl(meta.functionName, ast);
+        }
+        singleton()(target);
+    };
+}
+
+export { pgJsonRepository };

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

@@ -0,0 +1,14 @@
+import { container } from '../../../core/injection/index.js';
+import { PgRepositoryMetadataStore } from './PgRepositoryMetadataStore.js';
+
+function query() {
+    return function (target, propertyKey) {
+        const store = container.resolve(PgRepositoryMetadataStore);
+        store.saveQueryMethodMetadata({
+            repositoryConstructor: target.constructor,
+            functionName: propertyKey.toString(),
+        });
+    };
+}
+
+export { query };

package/dist/src/feature/pg/query/PgJsonRepository.js

@@ -0,0 +1,23 @@
+import { __decorate, __metadata } from 'tslib';
+import { Pool } from 'pg';
+import { injectable, container } from '../../../core/injection/index.js';
+import { PgCrudRepository } from '../PgCrudRepository.js';
+import { PgRepositoryMetadataStore } from './PgRepositoryMetadataStore.js';
+
+let PgJsonRepository = class PgJsonRepository extends PgCrudRepository {
+    constructor(pool) {
+        const ctor = new.target;
+        const store = container.resolve(PgRepositoryMetadataStore);
+        const config = store.getRepositoryConfig(ctor);
+        if (!config) {
+            throw new Error(`${ctor.name} must be decorated with @pgJsonRepository`);
+        }
+        super(pool, config);
+    }
+};
+PgJsonRepository = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Pool])
+], PgJsonRepository);
+
+export { PgJsonRepository };

package/dist/src/feature/pg/query/PgRepositoryMetadataStore.js

@@ -0,0 +1,44 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+
+let PgRepositoryMetadataStore = class PgRepositoryMetadataStore {
+    queryMethods = new Map();
+    repositoryConfigs = new Map();
+    saveQueryMethodMetadata(metadata) {
+        let perClass = this.queryMethods.get(metadata.repositoryConstructor);
+        if (!perClass) {
+            perClass = new Map();
+            this.queryMethods.set(metadata.repositoryConstructor, perClass);
+        }
+        perClass.set(metadata.functionName, metadata);
+    }
+    saveRepositoryConfig(ctor, config) {
+        this.repositoryConfigs.set(ctor, config);
+    }
+    getRepositoryConfig(ctor) {
+        return this.repositoryConfigs.get(ctor);
+    }
+    getQueryMethods(ctor) {
+        const collected = new Map();
+        const hierarchy = [];
+        let proto = ctor.prototype;
+        while (proto && proto.constructor !== Object) {
+            hierarchy.unshift(proto.constructor);
+            proto = Object.getPrototypeOf(proto);
+        }
+        for (const cls of hierarchy) {
+            const perClass = this.queryMethods.get(cls);
+            if (perClass) {
+                for (const [name, meta] of perClass) {
+                    collected.set(name, meta);
+                }
+            }
+        }
+        return [...collected.values()];
+    }
+};
+PgRepositoryMetadataStore = __decorate([
+    singleton()
+], PgRepositoryMetadataStore);
+
+export { PgRepositoryMetadataStore };