"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.globalProviderFactory = exports.ProviderFactory = void 0;
exports.createProviderFromEnv = createProviderFromEnv;
exports.initializeFactoryFromEnv = initializeFactoryFromEnv;
const gitea_provider_js_1 = require("./gitea-provider.js");
const github_provider_js_1 = require("./github-provider.js");
/**
* Factory para criar e gerenciar providers VCS
* Suporta Gitea e GitHub com configuração flexível
*/
class ProviderFactory {
providers = new Map();
defaultProviderName = '';
constructor(config) {
if (config) {
this.initializeFromConfig(config);
}
}
/**
* Inicializa a factory a partir de uma configuração
*/
initializeFromConfig(config) {
this.defaultProviderName = config.defaultProvider;
for (const providerConfig of config.providers) {
this.createProvider(providerConfig);
}
}
/**
* Cria um novo provider baseado na configuração
*/
createProvider(config) {
let provider;
switch (config.type) {
case 'gitea':
provider = new gitea_provider_js_1.GiteaProvider(config);
break;
case 'github':
provider = new github_provider_js_1.GitHubProvider(config);
break;
default:
throw new Error(`Provider type '${config.type}' not supported. Supported types: gitea, github`);
}
this.providers.set(config.name, provider);
// Se for o primeiro provider, define como padrão
if (this.providers.size === 1) {
this.defaultProviderName = config.name;
}
return provider;
}
/**
* Obtém um provider pelo nome
*/
getProvider(name) {
const provider = this.providers.get(name);
if (!provider && name) {
console.error(`Provider '${name}' não encontrado. Providers disponíveis:`, Array.from(this.providers.keys()));
return undefined;
}
return provider;
}
/**
* Lista todos os nomes de providers disponíveis
*/
listProviders() {
return Array.from(this.providers.keys());
}
/**
* Obtém o provider padrão
*/
getDefaultProvider() {
if (this.providers.size === 0) {
throw new Error('No providers configured - this should not happen');
}
// Primeiro tenta o provider padrão configurado
if (this.defaultProviderName && this.providers.has(this.defaultProviderName)) {
const provider = this.providers.get(this.defaultProviderName);
if (provider) {
return provider;
}
}
// Fallback: usa o primeiro provider disponível
const firstKey = this.providers.keys().next().value;
if (firstKey) {
// console.log(`[PROVIDER FACTORY] Usando provider '${firstKey}' como fallback padrão`);
this.defaultProviderName = firstKey;
return this.providers.get(firstKey);
}
throw new Error('No valid providers available');
}
/**
* Define o provider padrão
*/
setDefaultProvider(name) {
if (!this.providers.has(name)) {
throw new Error(`Provider '${name}' not found`);
}
this.defaultProviderName = name;
}
/**
* Remove um provider
*/
removeProvider(name) {
const removed = this.providers.delete(name);
// Se o provider removido era o padrão, redefine o padrão
if (removed && name === this.defaultProviderName) {
if (this.providers.size > 0) {
const firstKey = this.providers.keys().next().value;
if (firstKey) {
this.defaultProviderName = firstKey;
}
else {
this.defaultProviderName = '';
}
}
else {
this.defaultProviderName = '';
}
}
return removed;
}
/**
* Verifica se um provider existe
*/
hasProvider(name) {
return this.providers.has(name);
}
/**
* Obtém informações sobre todos os providers
*/
getProvidersInfo() {
return Array.from(this.providers.entries()).map(([name, provider]) => ({
name,
type: provider.config?.type || 'unknown',
isDefault: name === this.defaultProviderName
}));
}
/**
* Limpa todos os providers
*/
clear() {
this.providers.clear();
this.defaultProviderName = '';
}
/**
* Obtém o número total de providers
*/
getProviderCount() {
return this.providers.size;
}
/**
* Verifica se há providers configurados
*/
isEmpty() {
return this.providers.size === 0;
}
}
exports.ProviderFactory = ProviderFactory;
/**
* Factory singleton global para uso em todo o sistema
*/
// Inicializar o provider factory global com configuração do ambiente
exports.globalProviderFactory = initializeFactoryFromEnv();
/**
* Função helper para criar provider a partir de variáveis de ambiente
*/
function createProviderFromEnv(providerName, providerType) {
let apiUrl;
let token;
let username;
switch (providerType) {
case 'gitea':
apiUrl = process.env.GITEA_URL || process.env.API_URL || '';
token = process.env.GITEA_TOKEN || process.env.API_TOKEN || '';
username = process.env.GITEA_USERNAME || process.env.USERNAME;
break;
case 'github':
apiUrl = process.env.GITHUB_URL || process.env.API_URL || 'https://api.github.com';
token = process.env.GITHUB_TOKEN || process.env.API_TOKEN || '';
username = process.env.GITHUB_USERNAME || process.env.USERNAME;
break;
default:
throw new Error(`Provider type '${providerType}' not supported`);
}
if (!apiUrl) {
throw new Error(`API URL not configured for ${providerType}`);
}
if (!token) {
throw new Error(`API token not configured for ${providerType}`);
}
const config = {
name: providerName,
type: providerType,
apiUrl,
baseUrl: providerType === 'github' ? 'https://github.com' : apiUrl.replace('/api/v1', ''),
token,
username
};
return exports.globalProviderFactory.createProvider(config);
}
/**
* Função helper para inicializar factory a partir de variáveis de ambiente
*/
function initializeFactoryFromEnv() {
const providers = [];
let defaultProvider = '';
// Verifica se há configuração multi-provider
const providersJson = process.env.PROVIDERS_JSON;
if (providersJson) {
try {
const config = JSON.parse(providersJson);
if (config.providers && Array.isArray(config.providers)) {
for (const providerConfig of config.providers) {
if (providerConfig.name && providerConfig.type && providerConfig.apiUrl && providerConfig.token) {
providers.push(providerConfig);
}
}
defaultProvider = config.defaultProvider || (providers[0]?.name || '');
}
}
catch (error) {
console.error('Error parsing PROVIDERS_JSON:', error);
}
}
// Se não há configuração multi-provider, tenta configuração individual
if (providers.length === 0) {
// Auto-detectar configuração multi-provider se ambos Gitea e GitHub estão configurados
if (process.env.GITEA_URL && process.env.GITEA_TOKEN && process.env.GITHUB_TOKEN) {
// Configuração multi-provider com Gitea como padrão
providers.push({
name: 'gitea',
type: 'gitea',
apiUrl: process.env.GITEA_URL,
baseUrl: process.env.GITEA_URL?.replace('/api/v1', '') || process.env.GITEA_URL,
token: process.env.GITEA_TOKEN,
username: process.env.GITEA_USERNAME
});
providers.push({
name: 'github',
type: 'github',
apiUrl: process.env.GITHUB_URL || 'https://api.github.com',
baseUrl: 'https://github.com',
token: process.env.GITHUB_TOKEN,
username: process.env.GITHUB_USERNAME
});
defaultProvider = 'gitea';
}
else {
// Só configura GitHub se token válido estiver disponível
if (process.env.GITHUB_TOKEN) {
providers.push({
name: 'github',
type: 'github',
apiUrl: process.env.GITHUB_URL || 'https://api.github.com',
baseUrl: 'https://github.com',
token: process.env.GITHUB_TOKEN,
username: process.env.GITHUB_USERNAME
});
defaultProvider = 'github';
// console.log('[PROVIDER FACTORY] Provider GitHub configurado');
}
// Tenta Gitea se disponível
if (process.env.GITEA_URL && process.env.GITEA_TOKEN) {
// Valida URL do Gitea
const giteaUrl = process.env.GITEA_URL;
if (!giteaUrl.includes('://')) {
console.warn('[PROVIDER FACTORY] GITEA_URL deve incluir protocolo (http:// ou https://)');
}
else {
providers.push({
name: 'gitea',
type: 'gitea',
apiUrl: giteaUrl,
baseUrl: giteaUrl.replace('/api/v1', ''),
token: process.env.GITEA_TOKEN,
username: process.env.GITEA_USERNAME
});
// Se não há provider padrão, usa Gitea
if (!defaultProvider) {
defaultProvider = 'gitea';
}
// console.log('[PROVIDER FACTORY] Provider Gitea configurado');
}
}
}
// Tenta configuração genérica
if (process.env.API_URL && process.env.API_TOKEN && providers.length === 0) {
const providerType = process.env.PROVIDER || 'gitea';
providers.push({
name: providerType,
type: providerType,
apiUrl: process.env.API_URL,
baseUrl: providerType === 'github' ? 'https://github.com' : process.env.API_URL?.replace('/api/v1', '') || process.env.API_URL,
token: process.env.API_TOKEN,
username: process.env.USERNAME
});
defaultProvider = providerType;
}
}
// Se não há providers configurados, cria um provider demo
if (providers.length === 0) {
console.warn('[PROVIDER FACTORY] Nenhum provider configurado, usando modo demo');
providers.push({
name: 'demo',
type: 'gitea',
apiUrl: 'https://demo.gitea.io/api/v1',
baseUrl: 'https://demo.gitea.io',
token: 'demo-token',
username: 'demo-user'
});
defaultProvider = 'demo';
}
const config = {
defaultProvider,
providers
};
return new ProviderFactory(config);
}
//# sourceMappingURL=provider-factory.js.map
