linkio 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 64d4ce7d3188df34bc7eca2fe8a757d69549a5a259c58f0f0a62cc5b908a5e6b
+  data.tar.gz: 15560070030e575ba7a08bf68f1e8ee90f31de139118c24b19282a192c502555
+SHA512:
+  metadata.gz: a61cffbb4f5f2a7a7f406a90c8f91e8c920c04be3d572c1f2c1050ef22e340f4771d0cf80cc6d0451b6cb8e87ca369d4228935909bce11be2524976cf4da9bc0
+  data.tar.gz: 8944ecce09f0a936c3623e6aa88cd28ecddeffcfb96f052d167eed4c5cda2af59fddbb31333e7381eee90ca9ec724a7a678572762b7759c94a62b281d24e82e9

data/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- **Role-based multi-app routing.** Register multiple app targets with
+  `config.app "role" do |app| … end` and route on a configurable query/path
+  param (`config.role_param`, default `"role"`, with `config.default_role` as
+  the fallback). One link such as `/link?code=ABC&role=vendor` now opens the
+  matching app, falls back to that role's store on mobile, and redirects per
+  role on web.
+- Per-target `fallback_url` with `{param}` templating for role-specific
+  redirects when the app is not installed (or for web visitors).
+- `apple-app-site-association` and `assetlinks.json` now aggregate an entry for
+  every configured app target.
+- `LinkIO::AppTarget` and `LinkIO::Utils.interpolate`.
+
+### Changed
+
+- Single-app (flat) configuration is now the one-target special case of the
+  multi-app model and remains fully backward compatible.
+
+## [1.0.0] - 2026-07-08
+
+### Added
+
+- Initial release — Ruby port of the Node.js LinkIO backend.
+- Framework-agnostic `LinkIO::Client` with deep link handling, deferred deep
+  linking (IP fingerprint + device id), referral tracking, and generation of
+  `apple-app-site-association` and `assetlinks.json` documents.
+- Smart redirect page that attempts to open the native app before falling back
+  to the App Store / Play Store.
+- Pluggable storage: `LinkIO::Storage::InMemoryStorage`,
+  `LinkIO::Storage::RedisStorage`, and a `LinkIO::Storage::Base` interface for
+  custom adapters. Redis keys are namespaced identically to the Node.js backend.
+- Mountable Rails engine (`LinkIO::Engine`) with controllers and routes, plus a
+  `linkio:install` generator.
+- Rack middleware (`LinkIO::Rack::Middleware`) for non-Rails apps.
+- Full RSpec test suite and RuboCop configuration.
+
+[1.0.0]: https://github.com/pt-nakul-sharma/linkio-rails/releases/tag/v1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nakul Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,295 @@
+# LinkIO (Ruby)
+
+**Self-hosted deep linking for mobile apps — an open-source alternative to Branch.io.**
+
+LinkIO is the Ruby port of [LinkIO-Backend](https://github.com/pt-nakul-sharma/LinkIO-Backend) (Node.js). It gives you universal/app links, smart app-or-store redirects, fingerprint-based deferred deep linking, and referral tracking — with a framework-agnostic core, a mountable **Rails engine**, and **Rack middleware**.
+
+[![CI](https://github.com/pt-nakul-sharma/linkio-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/pt-nakul-sharma/linkio-rails/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/linkio.svg)](https://rubygems.org/gems/linkio)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## Features
+
+- **Universal Links (iOS)** — automatic `apple-app-site-association` generation
+- **App Links (Android)** — automatic `assetlinks.json` generation
+- **Smart redirect** — tries to open the installed app, then falls back to the App Store / Play Store after a configurable timeout
+- **Deferred deep linking** — IP-fingerprint matching preserves link data across the browser → install → app-open journey (works even when User-Agents differ)
+- **Referral tracking** — record and query referrer → referee relationships
+- **Role-based multi-app routing** — one link (`?code=…&role=…`) can open different apps (e.g. a User app vs a Vendor app) and fall back per role
+- **Pluggable storage** — in-memory, Redis, or your own adapter
+- **Three ways to mount** — plain Ruby, a Rails engine, or Rack middleware
+- Fully tested with RSpec, zero required runtime dependencies
+- **Runs on Ruby 3.0 through 3.4 and `head`**
+
+## Installation
+
+```ruby
+# Gemfile
+gem "linkio"
+```
+
+```bash
+bundle install
+# or
+gem install linkio
+```
+
+Requires Ruby >= 3.0 (tested on 3.0–3.4 and `head`).
+
+---
+
+## Quick start (Rails)
+
+LinkIO ships a mountable engine. Generate the initializer:
+
+```bash
+rails generate linkio:install
+```
+
+Fill in your identifiers in `config/initializers/linkio.rb`:
+
+```ruby
+LinkIO.configure do |config|
+  config.domain = "yourdomain.com"
+
+  # iOS
+  config.ios_app_id = "123456789"
+  config.ios_team_id = "TEAMID123"
+  config.ios_bundle_id = "com.yourapp"
+  config.ios_app_scheme = "yourapp"           # yourapp://
+
+  # Android
+  config.android_package_name = "com.yourapp"
+  config.android_app_scheme = "yourapp"        # yourapp://
+  config.android_sha256_fingerprints = ["AA:BB:CC:...:99"]
+
+  config.fallback_timeout = 2500               # ms before falling back to the store
+
+  # Development. Use RedisStorage in production (see below).
+  config.storage = LinkIO::Storage::InMemoryStorage.new
+end
+```
+
+Mount the engine **at the domain root** (so the `/.well-known` files resolve):
+
+```ruby
+# config/routes.rb
+mount LinkIO::Engine => "/"
+```
+
+That exposes:
+
+| Method | Path | Purpose |
+| ------ | ---- | ------- |
+| GET | `/.well-known/apple-app-site-association` | iOS universal-link verification |
+| GET | `/.well-known/assetlinks.json` | Android app-link verification |
+| GET | `/link` | Generic deep link handler (any query params) |
+| GET | `/pending-link` | Retrieve deferred link by client IP fingerprint |
+| GET | `/pending-link/:device_id` | Retrieve deferred link by device id |
+| POST | `/track-referral` | Record a referral (`referralCode`, `userId`, `metadata`) |
+| GET | `/referrals/:referrer_id` | List referrals for a referrer |
+
+---
+
+## Quick start (Rack / Sinatra / any Rack app)
+
+```ruby
+# config.ru
+require "linkio"
+require "redis"
+
+LinkIO.configure do |config|
+  config.domain = "yourdomain.com"
+  config.ios_app_id = "123456789"
+  config.ios_team_id = "TEAMID123"
+  config.ios_bundle_id = "com.yourapp"
+  config.ios_app_scheme = "yourapp"
+  config.android_package_name = "com.yourapp"
+  config.android_app_scheme = "yourapp"
+  config.android_sha256_fingerprints = ["AA:BB:CC:...:99"]
+  config.storage = LinkIO::Storage::RedisStorage.new(Redis.new)
+end
+
+use LinkIO::Rack::Middleware          # uses LinkIO.client by default
+run ->(_env) { [404, { "content-type" => "text/plain" }, ["Not found"]] }
+```
+
+The middleware handles the LinkIO routes and passes everything else through to your app. Pass an explicit client with `use LinkIO::Rack::Middleware, client: my_client`.
+
+---
+
+## Using the core directly
+
+The engine and middleware are thin wrappers around `LinkIO::Client`, which you can use anywhere:
+
+```ruby
+client = LinkIO::Client.new(
+  domain: "yourdomain.com",
+  ios_app_id: "123456789",
+  ios_team_id: "TEAMID123",
+  ios_bundle_id: "com.yourapp",
+  ios_app_scheme: "yourapp",
+  android_package_name: "com.yourapp",
+  android_app_scheme: "yourapp",
+  android_sha256_fingerprints: ["AA:BB:CC:...:99"],
+  storage: LinkIO::Storage::InMemoryStorage.new
+)
+
+# Handle a deep link — returns a LinkIO::Result (redirect / html / json)
+request = LinkIO::Request.from_rack(env)          # or build one yourself
+result  = client.handle_deep_link(request)
+result.redirect?   # => true/false
+result.location    # => store URL (for redirects)
+result.body        # => HTML string or Ruby hash (json)
+
+# Deferred deep linking (called by your mobile SDK after install)
+client.pending_link_by_fingerprint(client_ip)     # => LinkIO::DeepLinkData | nil
+client.pending_link(device_id)                     # => LinkIO::DeepLinkData | nil
+
+# Referrals
+client.track_referral("CODE123", "user-42", { campaign: "summer" })
+client.referrals("CODE123")                        # => [LinkIO::ReferralData]
+client.referral_for_user("user-42")                # => LinkIO::ReferralData | nil
+
+# Verification documents
+client.apple_app_site_association                  # => Hash
+client.asset_links                                 # => Array<Hash>
+```
+
+`LinkIO::Request` fields: `user_agent`, `full_url`, `query_params`, `path_params`, `client_ip`, `device_id`. Build one from a Rack env with `LinkIO::Request.from_rack(env)`, or construct it directly for full control.
+
+---
+
+## Role-based routing (multiple apps)
+
+Have more than one app — say a **User** app and a **Vendor** app — and want a single referral link to open the right one? Register an app target per role and LinkIO routes on a query/path param (default `role`):
+
+```ruby
+LinkIO.configure do |config|
+  config.domain = "rokart.in"
+  config.role_param  = "role"    # which param selects the app (default: "role")
+  config.default_role = "user"   # used when role is missing or unknown
+
+  config.app "user" do |app|
+    app.ios_app_id = "111111111"
+    app.ios_team_id = "TEAMID123"
+    app.ios_bundle_id = "com.rokart.user"
+    app.ios_app_scheme = "rokartuser"
+    app.android_package_name = "com.rokart.user"
+    app.android_app_scheme = "rokartuser"
+    app.android_sha256_fingerprints = ["AA:BB:...:99"]
+    # Optional: where to send visitors when the app isn't installed (per role).
+    app.fallback_url = "https://rokart.in/refer?code={code}&role=user"
+  end
+
+  config.app "vendor" do |app|
+    app.ios_app_id = "222222222"
+    app.ios_team_id = "TEAMID123"
+    app.ios_bundle_id = "com.rokart.vendor"
+    app.ios_app_scheme = "rokartvendor"
+    app.android_package_name = "com.rokart.vendor"
+    app.android_app_scheme = "rokartvendor"
+    app.android_sha256_fingerprints = ["CC:DD:...:11"]
+    app.fallback_url = "https://rokart.in/refer?code={code}&role=vendor"
+  end
+
+  config.storage = LinkIO::Storage::InMemoryStorage.new
+end
+```
+
+Now share `https://rokart.in/link?code=ABC123&role=vendor`:
+
+| Visitor | Behaviour |
+| ------- | --------- |
+| iOS/Android with the **Vendor** app | Smart-redirect page opens `rokartvendor://link?code=ABC123&role=vendor` |
+| Mobile **without** the app installed | Falls back to that role's `fallback_url` (or, if none set, that role's App Store / Play Store listing) |
+| Desktop / web | Redirects to the role's `fallback_url` (or returns a JSON "open on mobile" message if none set) |
+| `role` missing or unrecognised | Uses `default_role` (here, `user`) |
+
+**Fallback URL templating.** `fallback_url` supports `{param}` placeholders filled (and URL-encoded) from the link's query — e.g. `https://rokart.in/refer?code={code}&role=vendor` becomes `…?code=ABC123&role=vendor`. Any query param can be interpolated, so this is fully generic — add `region`, `campaign`, etc. as needed.
+
+**Verification files.** `apple-app-site-association` and `assetlinks.json` automatically include an entry for **every** registered app target, so both apps verify from the one domain.
+
+The single-app (flat) configuration shown earlier is just the special case of one target — everything above still applies with `role` simply ignored.
+
+---
+
+## Storage
+
+Any object implementing the `LinkIO::Storage::Base` interface can back LinkIO.
+
+### In-memory (development)
+
+```ruby
+config.storage = LinkIO::Storage::InMemoryStorage.new
+```
+
+Process-local and thread-safe. Data is lost on restart and not shared between workers — don't use it in production.
+
+### Redis (production)
+
+```ruby
+require "redis"
+config.storage = LinkIO::Storage::RedisStorage.new(Redis.new)
+```
+
+Keys are namespaced (`linkio:pending:*`, `linkio:fingerprint:*`, `linkio:referral:*`, `linkio:referrer:*`) identically to the Node.js backend, so both implementations can share a Redis. Pending links are written with a TTL and expire automatically.
+
+### Custom
+
+Subclass `LinkIO::Storage::Base` and implement the nine methods (`save_pending_link`, `get_pending_link`, `delete_pending_link`, the three `*_by_fingerprint` variants, `save_referral`, `get_referrals_by_referrer`, `get_referral_by_referee`). Pending-link methods take/return `LinkIO::PendingLinkData`; referral methods take/return `LinkIO::ReferralData`. Both expose `#to_h` / `.from_h` for JSON-compatible (camelCase) serialization.
+
+---
+
+## Configuration reference
+
+**Top-level options:**
+
+| Option | Required | Default | Description |
+| ------ | -------- | ------- | ----------- |
+| `domain` | ✅ | — | Your linking domain |
+| `storage` | ✅ | — | A `LinkIO::Storage::Base` implementation |
+| `role_param` | | `"role"` | Query/path param used to select an app target |
+| `default_role` | | — | App target used when `role_param` is missing/unknown |
+| `fallback_timeout` | | `2500` | ms before the redirect page falls back |
+| `default_deep_link_path` | | — | Reserved for future use |
+
+**Per-app-target options** (set directly on `config` for a single app, or inside `config.app "role" do |app| … end` for multiple):
+
+| Option | Required | Default | Description |
+| ------ | -------- | ------- | ----------- |
+| `ios_app_id` | ✅ | — | Apple numeric app id (App Store URL) |
+| `ios_team_id` | ✅ | — | Apple developer Team ID (AASA `appID`) |
+| `ios_bundle_id` | ✅ | — | iOS bundle identifier (AASA `appID`) |
+| `ios_app_scheme` | | — | Custom scheme, e.g. `yourapp` → `yourapp://` |
+| `android_package_name` | ✅ | — | Android package name |
+| `android_app_scheme` | | — | Custom scheme for Android |
+| `android_sha256_fingerprints` | | `[]` | SHA-256 signing cert fingerprints for `assetlinks.json` |
+| `fallback_url` | | — | Per-role destination when the app isn't installed / on web; supports `{param}` templating |
+
+If `ios_app_scheme` / `android_app_scheme` is omitted, LinkIO redirects straight to the fallback (store or `fallback_url`) instead of rendering the smart-redirect page.
+
+---
+
+## Ecosystem
+
+LinkIO pairs with the platform SDKs: **LinkIO-iOS**, **LinkIO-Android**, and **LinkIO-React-Native**, plus the Node.js backend it is ported from.
+
+## Development
+
+```bash
+bin/setup            # bundle install
+bundle exec rspec    # run tests
+bundle exec rubocop  # lint
+bundle exec rake     # both
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome at <https://github.com/pt-nakul-sharma/linkio-rails>.
+
+## License
+
+Released under the [MIT License](LICENSE).

data/app/controllers/linkio/application_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LinkIO
+  # Base controller for the engine. Provides access to the configured client
+  # and a helper to render a {LinkIO::Result}.
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :null_session
+
+    private
+
+    # @return [LinkIO::Client]
+    def linkio_client
+      LinkIO.client
+    end
+
+    # Build a framework-agnostic {LinkIO::Request} from the Rails request.
+    #
+    # @return [LinkIO::Request]
+    def linkio_request
+      ip = LinkIO::Utils.client_ip(
+        forwarded_for: request.headers["X-Forwarded-For"],
+        ip: request.remote_ip,
+        remote_address: request.remote_addr
+      )
+      device_id = params[:deviceId] || request.headers["X-Device-Id"]
+
+      LinkIO::Request.new(
+        user_agent: request.user_agent,
+        full_url: request.original_url,
+        query_params: request.query_parameters,
+        path_params: request.path_parameters.except(:controller, :action),
+        client_ip: ip,
+        device_id: device_id
+      )
+    end
+
+    # Render a {LinkIO::Result} through the Rails response.
+    #
+    # @param result [LinkIO::Result]
+    def render_linkio(result)
+      if result.redirect?
+        redirect_to result.location, status: result.status, allow_other_host: true
+      elsif result.json?
+        render json: result.body, status: result.status
+      else
+        render html: result.body.html_safe, status: result.status, content_type: result.headers["content-type"]
+      end
+    end
+  end
+end

data/app/controllers/linkio/deep_links_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LinkIO
+  # Handles incoming deep links (GET /link). Stores a pending link for deferred
+  # deep linking and redirects to the app or store based on platform.
+  class DeepLinksController < ApplicationController
+    def show
+      render_linkio(linkio_client.handle_deep_link(linkio_request))
+    end
+  end
+end

data/app/controllers/linkio/pending_links_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LinkIO
+  # Retrieves pending links for deferred deep linking.
+  class PendingLinksController < ApplicationController
+    # GET /pending-link/:device_id
+    def by_device
+      deep_link = linkio_client.pending_link(params[:device_id])
+      respond_with_deep_link(deep_link)
+    end
+
+    # GET /pending-link  (matched by client IP fingerprint)
+    def by_fingerprint
+      ip = LinkIO::Utils.client_ip(
+        forwarded_for: request.headers["X-Forwarded-For"],
+        ip: request.remote_ip,
+        remote_address: request.remote_addr
+      )
+      deep_link = linkio_client.pending_link_by_fingerprint(ip, request.user_agent)
+      respond_with_deep_link(deep_link)
+    end
+
+    private
+
+    def respond_with_deep_link(deep_link)
+      if deep_link.nil?
+        render json: { error: "No pending link found" }, status: :not_found
+      else
+        render json: deep_link.to_h
+      end
+    end
+  end
+end

data/app/controllers/linkio/referrals_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LinkIO
+  # Tracks and lists referrals.
+  class ReferralsController < ApplicationController
+    # POST /track-referral
+    # Body: { referralCode:, userId:, metadata: }
+    def create
+      linkio_client.track_referral(
+        params[:referralCode],
+        params[:userId],
+        params[:metadata]&.to_unsafe_h
+      )
+      render json: { success: true }
+    end
+
+    # GET /referrals/:referrer_id
+    def index
+      referrals = linkio_client.referrals(params[:referrer_id])
+      render json: { referrals: referrals.map(&:to_h) }
+    end
+  end
+end

data/app/controllers/linkio/well_known_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LinkIO
+  # Serves the domain verification files required by iOS and Android.
+  class WellKnownController < ApplicationController
+    # GET /.well-known/apple-app-site-association
+    def apple_app_site_association
+      render json: linkio_client.apple_app_site_association
+    end
+
+    # GET /.well-known/assetlinks.json
+    def asset_links
+      render json: linkio_client.asset_links
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+LinkIO::Engine.routes.draw do
+  # Domain verification files (must be reachable at the domain root).
+  get "/.well-known/apple-app-site-association", to: "well_known#apple_app_site_association"
+  get "/.well-known/assetlinks.json", to: "well_known#asset_links"
+
+  # Generic deep link handler, e.g. /link?referralCode=ABC123
+  get "/link", to: "deep_links#show"
+
+  # Deferred deep linking.
+  get "/pending-link", to: "pending_links#by_fingerprint"
+  get "/pending-link/:device_id", to: "pending_links#by_device", constraints: { device_id: %r{[^/]+} }
+
+  # Referrals.
+  post "/track-referral", to: "referrals#create"
+  get "/referrals/:referrer_id", to: "referrals#index", constraints: { referrer_id: %r{[^/]+} }
+end

data/lib/generators/linkio/install/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module LinkIO
+  module Generators
+    # Installs LinkIO into a Rails app: creates an initializer and prints the
+    # route to mount.
+    #
+    #   rails generate linkio:install
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_initializer
+        template "linkio.rb", "config/initializers/linkio.rb"
+      end
+
+      def show_readme
+        say ""
+        say "LinkIO installed. Next steps:", :green
+        say "  1. Fill in your app identifiers in config/initializers/linkio.rb"
+        say "  2. Mount the engine at the domain root in config/routes.rb:"
+        say ""
+        say "       mount LinkIO::Engine => \"/\""
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/linkio/install/templates/linkio.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# LinkIO configuration.
+# Docs: https://github.com/pt-nakul-sharma/linkio-rails
+LinkIO.configure do |config|
+  config.domain = "example.com"
+
+  # Wait this many ms in the redirect page before falling back to the store.
+  config.fallback_timeout = 2500
+
+  # --- Single app -----------------------------------------------------------
+  # iOS
+  config.ios_app_id = "123456789"        # Apple app id (numeric)
+  config.ios_team_id = "TEAMID123"       # Apple developer Team ID
+  config.ios_bundle_id = "com.example.app"
+  config.ios_app_scheme = "example"      # custom URL scheme -> example://
+
+  # Android
+  config.android_package_name = "com.example.app"
+  config.android_app_scheme = "example" # custom URL scheme -> example://
+  config.android_sha256_fingerprints = [
+    "AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99"
+  ]
+
+  # Optional per-role fallback used on web, and on mobile when the app is not
+  # installed. Supports {param} placeholders filled from the link's query.
+  # config.fallback_url = "https://example.com/download?code={code}"
+
+  # --- Multiple apps by role (e.g. a referral link ?code=ABC&role=vendor) ---
+  # Remove the single-app block above and register one target per role instead.
+  # The `role` query/path param selects which app to open.
+  #
+  # config.role_param = "role"     # param used to route (default: "role")
+  # config.default_role = "user"   # used when role is missing/unknown
+  #
+  # config.app "user" do |app|
+  #   app.ios_app_id = "111111111"
+  #   app.ios_team_id = "TEAMID123"
+  #   app.ios_bundle_id = "com.example.user"
+  #   app.ios_app_scheme = "exampleuser"
+  #   app.android_package_name = "com.example.user"
+  #   app.android_app_scheme = "exampleuser"
+  #   app.android_sha256_fingerprints = ["AA:BB:...:99"]
+  #   app.fallback_url = "https://example.com/refer?code={code}&role=user"
+  # end
+  #
+  # config.app "vendor" do |app|
+  #   app.ios_app_id = "222222222"
+  #   app.ios_team_id = "TEAMID123"
+  #   app.ios_bundle_id = "com.example.vendor"
+  #   app.ios_app_scheme = "examplevendor"
+  #   app.android_package_name = "com.example.vendor"
+  #   app.android_app_scheme = "examplevendor"
+  #   app.android_sha256_fingerprints = ["CC:DD:...:11"]
+  #   app.fallback_url = "https://example.com/refer?code={code}&role=vendor"
+  # end
+
+  # Storage. InMemoryStorage is for development only.
+  # For production use RedisStorage:
+  #   require "redis"
+  #   config.storage = LinkIO::Storage::RedisStorage.new(Redis.new)
+  config.storage = LinkIO::Storage::InMemoryStorage.new
+end