Extending Services

apps/app/app/
├── types/              # Service interfaces
├── services/           # Service implementations
├── config/
│   ├── env.ts          # Environment variables (Zod validated)
│   └── features.ts     # Feature flags
└── app.tsx             # Service initialization

// apps/app/app/types/newservice.ts
export type NewServicePlatform = "newservice"

export interface NewServiceConfig {
  apiKey: string
  // Add platform-specific options as needed
}

export interface NewServiceInterface {
  platform: NewServicePlatform
  initialize(config: NewServiceConfig): Promise<void>

  // Define your service methods
  doSomething(data: unknown): Promise<void>

  // Optional cleanup
  destroy?(): Promise<void>
}

// apps/app/app/types/index.ts
export * from "./newservice"

const EnvSchema = z.object({
  // ... existing variables

  // New service
  newserviceApiKey: z.string().optional(),
})

export function isServiceConfigured(
  service: "supabase" | "revenuecat" | "posthog" | "sentry" | "newservice"
): boolean {
  switch (service) {
    // ... existing cases
    case "newservice":
      return !!env.newserviceApiKey
  }
}

export interface FeatureFlags {
  // ... existing flags
  enableNewService: boolean
}

function getFeatureFlags(): FeatureFlags {
  return {
    // ... existing flags
    enableNewService: isServiceConfigured("newservice"),
  }
}

// apps/app/app/services/newservice.ts
import { Platform } from "react-native"
import { env } from "../config/env"
import type { NewServiceInterface, NewServiceConfig } from "../types/newservice"
import { logger } from "../utils/Logger"

// Platform-specific SDK loading
let SDK: typeof import("newservice-sdk") | null = null

if (Platform.OS !== "web") {
  try {
    SDK = require("newservice-react-native")
  } catch {
    if (__DEV__) logger.warn("NewService SDK not available")
  }
} else {
  // Web SDK loaded differently if needed
}

class NewService implements NewServiceInterface {
  platform = "newservice" as const
  private initialized = false

  async initialize(config: NewServiceConfig): Promise<void> {
    if (this.initialized) return

    try {
      SDK?.configure(config.apiKey)
      this.initialized = true
      logger.info("NewService initialized")
    } catch (error) {
      logger.error("NewService init failed", {}, error as Error)
    }
  }

  async doSomething(data: unknown): Promise<void> {
    if (!this.initialized) {
      logger.warn("NewService not initialized")
      return
    }

    SDK?.doSomething(data)
  }

  async destroy(): Promise<void> {
    // Cleanup if needed
  }
}

// Export singleton
export const newservice: NewServiceInterface = new NewService()

// Export init function
export function initNewService(): void {
  if (!env.newserviceApiKey) {
    if (__DEV__) {
      logger.info("NewService not configured - skipping")
    }
    return
  }

  newservice.initialize({
    apiKey: env.newserviceApiKey,
  })
}

import { initNewService } from "./services/newservice"

// Inside useEffect with other service inits
useEffect(() => {
  InteractionManager.runAfterInteractions(() => {
    // ... existing inits
    initNewService()
  })
}, [])

import { newservice } from "@/services/newservice"
import { features } from "@/config/features"

function MyComponent() {
  useEffect(() => {
    if (features.enableNewService) {
      newservice.doSomething({ key: "value" })
    }
  }, [])
}

// types/pushNotifications.ts
export interface PushService {
  initialize(): Promise<void>
  requestPermission(): Promise<boolean>
  subscribe(userId: string): Promise<void>
  unsubscribe(): Promise<void>
}

// types/realtime.ts
export interface RealtimeService {
  connect(): Promise<void>
  subscribe<T>(query: string, callback: (data: T) => void): () => void
  mutate(mutation: string, args: unknown): Promise<void>
}

// Just implement the existing interface
import type { AnalyticsService } from "../types/analytics"

class AmplitudeService implements AnalyticsService {
  platform = "amplitude" as const
  // ... implement methods
}

// services/analytics.ts
import { AmplitudeService } from "./amplitude"
import { PostHogService } from "./posthog"

// Swap by changing this line
export const analytics: AnalyticsService = new AmplitudeService()
// export const analytics: AnalyticsService = new PostHogService()

let MobileSDK: typeof import("service-react-native") | null = null
let WebSDK: typeof import("service-js") | null = null

if (Platform.OS === "web") {
  import("service-js").then((module) => {
    WebSDK = module
  })
} else {
  try {
    MobileSDK = require("service-react-native")
  } catch {
    // SDK not installed
  }
}

// Then use the appropriate one
const sdk = Platform.OS === "web" ? WebSDK : MobileSDK

[NewService] initialized
// or
[NewService] not configured - skipping