OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.
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;
}