Skip to content

OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.

7.9 KB
Raw Blame
import type { Ctx } from './context';
import { createAiService } from './modules/ai/ai.service';
import { createAssistantService } from './modules/assistant/assistant.service';
import { createAuthService } from './modules/auth/auth.service';
import { createChartService } from './modules/chart/chart.service';
import { createConversionService } from './modules/chart/conversion.service';
import { createFunnelService } from './modules/chart/funnel.service';
import { createRetentionService } from './modules/chart/retention.service';
import { createSankeyService } from './modules/chart/sankey.service';
import { createClientService } from './modules/client/client.service';
import { createCohortService } from './modules/cohort/cohort.service';
import { createConversationService } from './modules/conversation/conversation.service';
import { createCustomEventService } from './modules/custom-event/custom-event.service';
import { createDashboardService } from './modules/dashboard/dashboard.service';
import { createEventService } from './modules/event/event.service';
import { createExportService } from './modules/export/export.service';
import { createGroupService } from './modules/group/group.service';
import { createGscService } from './modules/gsc/gsc.service';
import { createImportService } from './modules/import/import.service';
import { createIngestService } from './modules/ingest/ingest.service';
import { createInsightService } from './modules/insight/insight.service';
import { createIntegrationService } from './modules/integration/integration.service';
import { createMcpService } from './modules/mcp/mcp.service';
import { createMiscService } from './modules/misc/misc.service';
import { createNotificationService } from './modules/notification/notification.service';
import { createOnboardingService } from './modules/onboarding/onboarding.service';
import { createOrganizationService } from './modules/organization/organization.service';
import { createOverviewService } from './modules/overview/overview.service';
import { createPagesService } from './modules/overview/pages.service';
import { createProfileService } from './modules/profile/profile.service';
import { createProjectService } from './modules/project/project.service';
import { createRealtimeService } from './modules/realtime/realtime.service';
import { createReferenceService } from './modules/reference/reference.service';
import { createReportService } from './modules/report/report.service';
import { createSaltService } from './modules/salt/salt.service';
import { createSessionService } from './modules/session/session.service';
import { createShareService } from './modules/share/share.service';
import { createSubscriptionService } from './modules/subscription/subscription.service';
import { createUserService } from './modules/user/user.service';

/** What every service factory receives, derived from Ctx so it cannot drift. */
export type ServiceDeps = Pick<
  Ctx,
  | 'db'
  | 'prisma'
  | 'ch'
  | 'redis'
  | 'clients'
  | 'buffers'
  | 'logger'
  | 'queues'
  | 'config'
  | 'auth'
>;

// `Services` must stay an INTERFACE: a type alias over
// `ReturnType<typeof createServices>` is circular (every factory's signature
// names `Services`), and interface members resolve lazily. Every service
// method also needs an explicit return type or typecheck fails with
// ts7022/ts7023.
export interface Services {
  auth: ReturnType<typeof createAuthService>;
  insight: ReturnType<typeof createInsightService>;
  gsc: ReturnType<typeof createGscService>;
  cohort: ReturnType<typeof createCohortService>;
  import: ReturnType<typeof createImportService>;
  ingest: ReturnType<typeof createIngestService>;
  organization: ReturnType<typeof createOrganizationService>;
  integration: ReturnType<typeof createIntegrationService>;
  onboarding: ReturnType<typeof createOnboardingService>;
  notification: ReturnType<typeof createNotificationService>;
  session: ReturnType<typeof createSessionService>;
  customEvent: ReturnType<typeof createCustomEventService>;
  event: ReturnType<typeof createEventService>;
  profile: ReturnType<typeof createProfileService>;
  group: ReturnType<typeof createGroupService>;
  ai: ReturnType<typeof createAiService>;
  chart: ReturnType<typeof createChartService>;
  // One key per `*.service.ts`. `chart` keeps the composed facade its callers
  // use; the factories build stateless closures over `deps`, so binding a
  // sub-module twice binds the same functions, not a second piece of state.
  funnel: ReturnType<typeof createFunnelService>;
  conversion: ReturnType<typeof createConversionService>;
  sankey: ReturnType<typeof createSankeyService>;
  retention: ReturnType<typeof createRetentionService>;
  overview: ReturnType<typeof createOverviewService>;
  pages: ReturnType<typeof createPagesService>;
  realtime: ReturnType<typeof createRealtimeService>;
  misc: ReturnType<typeof createMiscService>;
  report: ReturnType<typeof createReportService>;
  dashboard: ReturnType<typeof createDashboardService>;
  export: ReturnType<typeof createExportService>;
  share: ReturnType<typeof createShareService>;
  reference: ReturnType<typeof createReferenceService>;
  client: ReturnType<typeof createClientService>;
  project: ReturnType<typeof createProjectService>;
  user: ReturnType<typeof createUserService>;
  subscription: ReturnType<typeof createSubscriptionService>;
  salt: ReturnType<typeof createSaltService>;
  conversation: ReturnType<typeof createConversationService>;
  assistant: ReturnType<typeof createAssistantService>;
  mcp: ReturnType<typeof createMcpService>;
}

// A hoisted `function` declaration, not a `const` arrow: a `const` would put
// any future ESM cycle through this file in a temporal dead zone that no
// typecheck reports and that fails at boot.
export function createServices(deps: ServiceDeps): Services {
  // The thunk is captured, not copied, so two services may call each other
  // without a cycle: `container` is assigned before any thunk body can run.
  const services = (): Services => container;
  const container: Services = {
    auth: createAuthService(deps, services),
    insight: createInsightService(deps, services),
    gsc: createGscService(deps, services),
    cohort: createCohortService(deps, services),
    import: createImportService(deps, services),
    ingest: createIngestService(deps, services),
    organization: createOrganizationService(deps, services),
    integration: createIntegrationService(deps, services),
    onboarding: createOnboardingService(deps, services),
    notification: createNotificationService(deps, services),
    session: createSessionService(deps, services),
    customEvent: createCustomEventService(deps, services),
    event: createEventService(deps, services),
    profile: createProfileService(deps, services),
    group: createGroupService(deps, services),
    ai: createAiService(deps, services),
    chart: createChartService(deps, services),
    funnel: createFunnelService(deps, services),
    conversion: createConversionService(deps, services),
    sankey: createSankeyService(deps, services),
    retention: createRetentionService(deps, services),
    overview: createOverviewService(deps, services),
    pages: createPagesService(deps, services),
    realtime: createRealtimeService(deps, services),
    misc: createMiscService(deps, services),
    report: createReportService(deps, services),
    dashboard: createDashboardService(deps, services),
    export: createExportService(deps, services),
    share: createShareService(deps, services),
    reference: createReferenceService(deps, services),
    client: createClientService(deps, services),
    project: createProjectService(deps, services),
    user: createUserService(deps, services),
    subscription: createSubscriptionService(deps, services),
    salt: createSaltService(deps, services),
    conversation: createConversationService(deps, services),
    assistant: createAssistantService(deps, services),
    mcp: createMcpService(deps, services),
  };
  return container;
}