Service Abstractions

Configure and manage infrastructure services in Kotlin Multiplatform applications.

Updated Jan 4, 2026
One-click install
npx skills add https://github.com/lightningkite/lightning-kite-skills --skill service-abstractions-lightningkite
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Service Abstractions
Source: https://github.com/lightningkite/lightning-kite-skills/tree/main/service-abstractions
Command: npx skills add https://github.com/lightningkite/lightning-kite-skills --skill service-abstractions-lightningkite

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Managing infrastructure services across multiplatform Kotlin projects typically requires custom wiring, boilerplate configuration, and manual setup. This skill provides a standardized approach to configure, instantiate, and manage services via a serializable Settings model and consistent lifecycle management, reducing boilerplate and increasing reliability.

Core Features & Use Cases

  • Settings-based service instantiation: Services are created from serializable configuration objects, enabling consistent initialization and testing.
  • Type-safe data interactions: Supports generated DataClassPath and HasId contracts for robust data access across modules.
  • Cross-platform support: Designed for Kotlin Multiplatform projects with pluggable implementations for databases, caches, and file systems.
  • Lifecycle and serverless readiness: Includes connect/disconnect hooks to support serverless environments and proper resource management.
  • OpenTelemetry integration: Optional tracing of service operations when a context-provided OpenTelemetry instance is present.

Quick Start

Instantiate a Settings object for your app, create a SettingContext, build services from Settings, then call connect() to initialize them.

Frequently Asked Questions about Service Abstractions

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I configure infrastructure services in a Kotlin Multiplatform project?

Configuring infrastructure services in Kotlin Multiplatform uses a serializable Settings model to instantiate databases, caches, and file systems. You create a SettingContext, build services from the Settings, and call connect() to initialize them across JVM, JS, and native targets.

What's the best way to manage database and cache connections across JVM and JS targets?

Managing database and cache connections across JVM and JS targets uses standardized connect/disconnect lifecycle hooks. This approach supports serverless environments and proper resource management by providing consistent initialization from a serializable configuration object.

Can I use type-safe settings for initializing Kotlin Multiplatform modules?

Type-safe settings for initializing Kotlin Multiplatform modules are supported through serializable configuration objects and generated DataClassPath contracts. This enables robust, type-safe data access and consistent service instantiation across different platform targets.

How does OpenTelemetry integration work with multiplatform service configurations?

OpenTelemetry integration with multiplatform service configurations provides optional tracing of service operations. When a context-provided OpenTelemetry instance is present, the system automatically traces interactions without requiring changes to the base service abstraction layer.

Does this approach to service abstraction require custom wiring for each platform?

This approach to service abstraction eliminates custom wiring and boilerplate setup for each platform. It provides pluggable implementations for databases, caches, and file systems using a standardized Settings model, increasing reliability across Kotlin Multiplatform projects.

When do I need type-safe service configurations for Kotlin applications?

Type-safe service configurations for Kotlin applications are needed when managing infrastructure services across multiplatform projects requires consistent initialization. They are essential for enabling settings-based instantiation, lifecycle management, and testing variants across JVM, JS, and native targets.