The minimalistic document archiving platform.
import type { GlobalDependencies } from './modules/app/server.types';
import type { Config } from './modules/config/config.types';
import type { Logger } from './modules/shared/logger/logger';
import { env } from 'node:process';
import { createAuthEmailsServices } from './modules/app/auth/auth.emails.services';
import { getAuth } from './modules/app/auth/auth.services';
import { setupDatabase } from './modules/app/database/database';
import { ensureLocalDatabaseDirectoryExists } from './modules/app/database/database.services';
import { registerEventHandlers } from './modules/app/events/events.handlers';
import { createEventServices } from './modules/app/events/events.services';
import { createGracefulShutdownService } from './modules/app/graceful-shutdown/graceful-shutdown.services';
import { getProcessMode } from './modules/app/process.models';
import { createServer } from './modules/app/server';
import { parseConfig } from './modules/config/config';
import { createDocumentSearchServices } from './modules/documents/document-search/document-search.registry';
import { createStorageService } from './modules/storage/storage.services';
import { createEmailsServices } from './modules/emails/emails.services';
import { createIngestionFolderWatcher } from './modules/ingestion-folders/ingestion-folders.usecases';
import { buildKvStore } from './modules/kv-store/kv-store';
import { addToGlobalLogContext, createLogger } from './modules/shared/logger/logger';
import { createSubscriptionsServices } from './modules/subscriptions/subscriptions.services';
import { registerTaskDefinitions } from './modules/tasks/tasks.definitions';
import { createTaskServices } from './modules/tasks/tasks.services';
import { createTrackingServices } from './modules/tracking/tracking.services';
import { createWebhookRepository } from './modules/webhooks/webhooks.repository';
import { createWebhookTriggerServices } from './modules/webhooks/webhooks.trigger.services';
import { createPlanEntitlementDefinitionRegistry } from './modules/plan-entitlements/plan-entitlements.registry';
import { createAiServices } from './modules/ai/ai.services';
import { createAiCreditsRepository } from './modules/ai-credits/ai-credits.repository';
import { createPlansRepository } from './modules/plans/plans.repository';
import { createPlanEntitlementsRepository } from './modules/plan-entitlements/plan-entitlements.repository';
import { createSubscriptionsRepository } from './modules/subscriptions/subscriptions.repository';
async function startWebMode({ logger, ...dependencies }: { logger: Logger } & GlobalDependencies) {
const server = createServer(dependencies);
server.start({
onStarted: ({ port }) => logger.info({ port }, 'Server started'),
});
}
async function startWorkerMode({ logger, ...deps }: { logger: Logger } & GlobalDependencies) {
const { taskServices, config } = deps;
if (config.ingestionFolder.isEnabled) {
const { startWatchingIngestionFolders } = createIngestionFolderWatcher(deps);
await startWatchingIngestionFolders();
}
await registerTaskDefinitions(deps);
taskServices.start();
logger.info('Worker started');
}
async function buildServices({ config }: { config: Config }): Promise<GlobalDependencies> {
const shutdownServices = createGracefulShutdownService();
await ensureLocalDatabaseDirectoryExists({ config });
const { db } = setupDatabase({ ...config.database, shutdownServices });
const documentsStorageService = createStorageService({
storageConfig: config.documentsStorage,
encryptionOptions: {
isEncryptionEnabled: config.documentsStorage.encryption.isEncryptionEnabled,
keyEncryptionKeys: config.documentsStorage.encryption.documentKeyEncryptionKeys,
},
});
const taskServices = createTaskServices({ config });
const trackingServices = createTrackingServices({ config, shutdownServices });
const eventServices = createEventServices();
const emailsServices = createEmailsServices({ config });
const authEmailsServices = createAuthEmailsServices({ emailsServices });
const { auth } = getAuth({ db, config, authEmailsServices, eventServices });
const subscriptionsServices = createSubscriptionsServices({ config });
const documentSearchServices = createDocumentSearchServices({ db, config });
const webhookRepository = createWebhookRepository({ db });
const webhookTriggerServices = createWebhookTriggerServices({
webhooksConfig: config.webhooks,
webhookRepository,
});
const kvStore = buildKvStore({ config, db });
const planEntitlementDefinitionRegistry = createPlanEntitlementDefinitionRegistry({ config });
const aiServices = createAiServices({
config,
aiCreditsRepository: createAiCreditsRepository({ db }),
planEntitlementDefinitionRegistry,
plansRepository: createPlansRepository({ config }),
planEntitlementsRepository: createPlanEntitlementsRepository({ db }),
subscriptionsRepository: createSubscriptionsRepository({ db }),
});
// --- Services initialization
await taskServices.initialize();
registerEventHandlers({
eventServices,
trackingServices,
db,
documentSearchServices,
config,
webhookTriggerServices,
documentsStorageService,
});
return {
config,
db,
shutdownServices,
documentsStorageService,
taskServices,
trackingServices,
eventServices,
emailsServices,
auth,
subscriptionsServices,
documentSearchServices,
webhookTriggerServices,
kvStore,
planEntitlementDefinitionRegistry,
aiServices,
};
}
export async function startApp() {
const logger = createLogger({ namespace: 'app-server' });
const { config } = await parseConfig({ env });
const { isWebMode, isWorkerMode, processMode } = getProcessMode({ config });
addToGlobalLogContext({ processMode });
logger.info({ isWebMode, isWorkerMode }, 'Starting application');
const globalDependencies = await buildServices({ config });
if (isWebMode) {
await startWebMode({ logger, ...globalDependencies });
}
if (isWorkerMode) {
await startWorkerMode({ logger, ...globalDependencies });
}
return {
shutdownServices: globalDependencies.shutdownServices,
};
}