Skip to content

armgit / papra

Public Imported from GitHub
0

The minimalistic document archiving platform.

6.1 KB
Raw Blame
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,
  };
}