dynamic_links 0.1.0 → 0.3.0

data/db/migrate/20240128030329_fix_citus_index.rb

@@ -0,0 +1,34 @@
+class FixCitusIndex < ActiveRecord::Migration[7.1]
+  def up
+    if DynamicLinks.configuration.db_infra_strategy == :sharding
+      # execute SQL to remove primary key constraint
+      execute <<-SQL
+        ALTER TABLE dynamic_links_shortened_urls
+        DROP CONSTRAINT dynamic_links_shortened_urls_pkey;
+      SQL
+
+      execute <<-SQL
+        ALTER TABLE dynamic_links_shortened_urls
+        ADD PRIMARY KEY (id, client_id);
+      SQL
+      create_distributed_table :dynamic_links_shortened_urls, :client_id
+    end
+  end
+
+  # this code is untested
+  def down
+    if DynamicLinks.configuration.db_infra_strategy == :sharding
+      drop_distributed_table :dynamic_links_shortened_urls, :client_id
+
+      execute <<-SQL
+        ALTER TABLE dynamic_links_shortened_urls
+        DROP CONSTRAINT dynamic_links_shortened_urls_pkey;
+      SQL
+
+      execute <<-SQL
+        ALTER TABLE dynamic_links_shortened_urls
+        ADD PRIMARY KEY (id);
+      SQL
+    end
+  end
+end

data/db/migrate/20240128030419_add_unique_index_to_shortened_urls.rb

@@ -0,0 +1,5 @@
+class AddUniqueIndexToShortenedUrls < ActiveRecord::Migration[7.1]
+  def change
+    add_index :dynamic_links_shortened_urls, [:client_id, :short_url], unique: true
+  end
+end

data/lib/dynamic_links/async/locker.rb

@@ -0,0 +1,60 @@
+module DynamicLinks
+  module Async
+    # @author Saiqul Haq <saiqulhaq@gmail.com>
+    class Locker
+      LockAcquisitionError = Class.new(StandardError)
+      LockReleaseError = Class.new(StandardError)
+      attr_reader :cache_store
+
+      def initialize(cache_store = DynamicLinks.configuration.cache_store)
+        @cache_store = cache_store
+      end
+
+      def generate_lock_key(client, url)
+        "lock:shorten_url#{client.id}:#{url_to_lock_key(url)}"
+      end
+
+      def locked?(lock_key)
+        cache_store.exist?(lock_key)
+      end
+
+      # Acquires a lock for the given key and executes the block if lock is acquired.
+      # This method won't release the lock after block execution.
+      # We release the lock in the job after the job is done.
+      # @param [String] lock_key, it's better to use generate_lock_key method to generate lock_key
+      # @param [Integer] expires_in, default is 60 seconds
+      # @param [Block] block, the block to be executed if lock is acquired
+      # @return [Boolean]
+      def lock_if_absent(lock_key, expires_in: 60, &block)
+        is_locked = false
+        begin
+          is_locked = cache_store.increment(lock_key, 1, expires_in: expires_in) == 1
+          yield if is_locked && block_given?
+
+          unless is_locked
+            DynamicLinks::Logger.log_info "Unable to acquire lock for key: #{lock_key}"
+          end
+        rescue => e
+          DynamicLinks::Logger.log_error("Locking error: #{e.message}")
+          raise e
+        end
+
+        is_locked
+      end
+
+      # Deletes an entry in the cache. Returns true if an entry is deleted and false otherwise.
+      # @return [Boolean]
+      def unlock(lock_key)
+        deleted = cache_store.delete(lock_key)
+        raise LockReleaseError, "Unable to release lock for key: #{lock_key}" unless deleted
+        deleted
+      end
+
+      private
+
+      def url_to_lock_key(url)
+        Digest::SHA256.hexdigest(url)
+      end
+    end
+  end
+end

data/lib/dynamic_links/configuration.rb

@@ -1,10 +1,102 @@
 module DynamicLinks
+  # @author Saiqul Haq <saiqulhaq@gmail.com>
   class Configuration
-    attr_accessor :shortening_strategy
+    attr_reader :shortening_strategy, :enable_rest_api, :db_infra_strategy,
+                  :async_processing, :redis_counter_config, :cache_store,
+                  :enable_fallback_mode, :firebase_host
 
+    VALID_DB_INFRA_STRATEGIES = [:standard, :sharding].freeze
+
+    DEFAULT_SHORTENING_STRATEGY = :md5
+    DEFAULT_ENABLE_REST_API = true
+    DEFAULT_DB_INFRA_STRATEGY = :standard
+    DEFAULT_ASYNC_PROCESSING = false
+    DEFAULT_REDIS_COUNTER_CONFIG = RedisConfig.new
+    # use any class that extends ActiveSupport::Cache::Store, default is MemoryStore
+    DEFAULT_CACHE_STORE = ActiveSupport::Cache::MemoryStore.new
+    DEFAULT_ENABLE_FALLBACK_MODE = false
+    DEFAULT_FIREBASE_HOST = nil
+
+    # Usage:
+    #     DynamicLinks.configure do |config|
+    #       config.shortening_strategy = :md5 # or other strategy name, see StrategyFactory for available strategies
+    #       config.enable_rest_api = true # or false. when false, the API requests will be rejected
+    #       config.db_infra_strategy = :standard # or :sharding. if sharding is used, then xxx
+    #       config.async_processing = false # or true. if true, the shortening process will be done asynchronously using ActiveJob
+    #       config.redis_counter_config = RedisConfig.new # see RedisConfig documentation for more details
+    #       # if you use Redis
+    #       config.cache_store = ActiveSupport::Cache::RedisCacheStore.new(url: 'redis://localhost:6379/0/cache')
+    #       # if you use Memcached
+    #       config.cache_store = ActiveSupport::Cache::MemCacheStore.new('localhost:11211')
+    #     end
+    #
+    # @return [Configuration]
     def initialize
-      @shortening_strategy = :MD5  # Default strategy
+      @shortening_strategy = DEFAULT_SHORTENING_STRATEGY
+      @enable_rest_api = DEFAULT_ENABLE_REST_API
+      @db_infra_strategy = DEFAULT_DB_INFRA_STRATEGY
+      @async_processing = DEFAULT_ASYNC_PROCESSING
+      # config for RedisCounterStrategy
+      @redis_counter_config = DEFAULT_REDIS_COUNTER_CONFIG
+      @cache_store = DEFAULT_CACHE_STORE
+      @enable_fallback_mode = DEFAULT_ENABLE_FALLBACK_MODE
+      @firebase_host = DEFAULT_FIREBASE_HOST
+    end
+
+    def shortening_strategy=(strategy)
+      unless StrategyFactory::VALID_SHORTENING_STRATEGIES.include?(strategy)
+        raise ArgumentError, "Invalid shortening strategy, provided strategy: #{strategy}. Valid strategies are: #{StrategyFactory::VALID_SHORTENING_STRATEGIES.join(', ')}" 
+      end
+
+      @shortening_strategy = strategy
+    end
+
+    def enable_rest_api=(value)
+      raise ArgumentError, "enable_rest_api must be a boolean" unless [true, false].include?(value)
+      @enable_rest_api = value
+    end
+
+    def db_infra_strategy=(strategy)
+      raise ArgumentError, "Invalid DB infra strategy" unless VALID_DB_INFRA_STRATEGIES.include?(strategy)
+      @db_infra_strategy = strategy
+    end
+
+    def async_processing=(value)
+      raise ArgumentError, "async_processing must be a boolean" unless [true, false].include?(value)
+      @async_processing = value
+    end
+
+    def redis_counter_config=(config)
+      raise ArgumentError, "redis_counter_config must be an instance of RedisConfig" unless config.is_a?(RedisConfig)
+      @redis_counter_config = config
+    end
+
+    def cache_store=(store)
+      raise ArgumentError, "cache_store must be an instance of ActiveSupport::Cache::Store" unless store.is_a?(ActiveSupport::Cache::Store)
+      @cache_store = store
+    end
+
+    def enable_fallback_mode=(value)
+      raise ArgumentError, "enable_fallback_mode must be a boolean" unless [true, false].include?(value)
+      @enable_fallback_mode = value
+    end
+
+    def firebase_host=(host)
+      # allow nil or blank host (optional, depends on your app logic)
+      if host.nil? || host.strip.empty?
+        @firebase_host = nil
+        return
+      end
+
+      begin
+        uri = URI.parse(host.to_s)
+        valid = uri.is_a?(URI::HTTP) && uri.host.present?
+        raise unless valid
+      rescue
+        raise ArgumentError, "firebase_host must be a valid URL with a host"
+      end
+
+      @firebase_host = host
     end
   end
 end
-

data/lib/dynamic_links/error_classes.rb

@@ -0,0 +1,6 @@
+module DynamicLinks
+  class InvalidURIError < ::URI::InvalidURIError; end
+  class ConfigurationError < StandardError; end
+  class MissingDependency < LoadError; end
+  class ShorteningFailed < StandardError; end
+end

data/lib/dynamic_links/logger.rb

@@ -0,0 +1,32 @@
+module DynamicLinks
+  # @author Saiqul Haq <saiqulhaq@gmail.com>
+  class Logger
+    def self.instance
+      @logger ||= Rails.logger
+    end
+
+    def self.log_info(message)
+      instance.info(message)
+    end
+
+    def self.log_error(message)
+      instance.error(message)
+    end
+
+    def self.log_warn(message)
+      instance.warn(message)
+    end
+
+    def self.log_debug(message)
+      instance.debug(message)
+    end
+
+    def self.log_fatal(message)
+      instance.fatal(message)
+    end
+
+    def self.log_unknown(message)
+      instance.unknown(message)
+    end
+  end
+end

data/lib/dynamic_links/redis_config.rb

@@ -0,0 +1,22 @@
+# @author Saiqul Haq <saiqulhaq@gmail.com>
+
+module DynamicLinks
+  # RedisConfig is a class to hold Redis configuration
+  class RedisConfig
+    attr_accessor :config, :pool_size, :pool_timeout
+
+    # @param [Hash] config
+    # Default to an empty hash, can be overridden
+    #    config = {
+    #      host: 'localhost',
+    #      port: 6379
+    #    }
+    # @param [Integer] pool_size Default to 5, can be overridden
+    # @param [Integer] pool_timeout Default to 5, can be overridden
+    def initialize(config = {}, pool_size = 5, pool_timeout = 5)
+      @config = config
+      @pool_size = pool_size
+      @pool_timeout = pool_timeout
+    end
+  end
+end

data/lib/dynamic_links/shortener.rb

@@ -0,0 +1,52 @@
+module DynamicLinks
+  # @author Saiqul Haq <saiqulhaq@gmail.com>
+  class Shortener
+    attr_reader :locker, :strategy, :storage, :async_worker
+
+    def initialize(locker: DynamicLinks::Async::Locker.new,
+                   strategy: StrategyFactory.get_strategy(DynamicLinks.configuration.shortening_strategy),
+                   storage: ShortenedUrl,
+                   async_worker: ShortenUrlJob)
+      @locker = locker
+      @strategy = strategy
+      @storage = storage
+      @async_worker = async_worker
+    end
+
+    # @param client [Client] the client that owns the url
+    # @param url [String] the url to be shortened
+    # @return [String] the shortened url
+    def shorten(client, url)
+      short_url = strategy.shorten(url)
+
+      if strategy.always_growing?
+        storage.create!(client: client, url: url, short_url: short_url)
+      else
+        storage.find_or_create!(client, short_url, url)
+      end
+      URI::Generic.build({scheme: client.scheme, host: client.hostname, path: "/#{short_url}"}).to_s
+    rescue => e
+      DynamicLinks::Logger.log_error("Error shortening URL: #{e.message}")
+      raise e
+    end
+
+    # @param client [Client] the client that owns the url
+    # @param url [String] the url to be shortened
+    def shorten_async(client, url)
+      lock_key = locker.generate_lock_key(client, url)
+
+      locker.lock_if_absent(lock_key) do
+        short_url = strategy.shorten(url)
+        content = {
+          url: url,
+          short_url: short_url
+        }
+
+        async_worker.perform_later(client, url, short_url, lock_key)
+      end
+    rescue => e
+      DynamicLinks::Logger.log_error("Error shortening URL asynchronously: #{e.message}")
+      raise e
+    end
+  end
+end

data/lib/dynamic_links/shortening_strategies/base_strategy.rb

@@ -9,6 +9,12 @@ module DynamicLinks
         raise NotImplementedError, "You must implement the shorten method"
       end
 
+      # Determines if the strategy always generates a new shortened URL
+      # @return [Boolean]
+      def always_growing?
+        false  # Default behavior is not to always grow
+      end
+
       private
 
       # Convert an integer into a Base62 string

data/lib/dynamic_links/shortening_strategies/nano_id_strategy.rb

@@ -3,17 +3,15 @@ module DynamicLinks
     # Shortens the given URL using Nano ID
     # This strategy will generate a different short URL for the same given URL
     class NanoIDStrategy < BaseStrategy
-      begin
-        require 'nanoid'
-      rescue LoadError
-        raise 'Missing dependency: Please add "nanoid" to your Gemfile to use NanoIdStrategy.'
-      end
-
       # Shortens the given URL using Nano ID
       # @param url [String] The URL to shorten (not directly used in Nano ID strategy)
-      # @param size [Integer] The size (length) of the generated Nano ID
-      def shorten(url, size: MIN_LENGTH)
-        ::Nanoid.generate(size: size)
+      # @param min_length [Integer] The size (length) of the generated Nano ID
+      def shorten(url, min_length: MIN_LENGTH)
+        ::Nanoid.generate(size: min_length)
+      end
+
+      def always_growing?
+        true  # This strategy always generates a new shortened URL
       end
     end
   end

data/lib/dynamic_links/shortening_strategies/redis_counter_strategy.rb

@@ -1,29 +1,40 @@
-
 module DynamicLinks
   module ShorteningStrategies
+    # usage:
+    # Using default configuration from DynamicLinks configuration
+    # default_strategy = DynamicLinks::ShorteningStrategies::RedisCounterStrategy.new
+    #
+    # Using a custom configuration
+    # custom_redis_config = { host: 'custom-host', port: 6380 }
+    # custom_strategy = DynamicLinks::ShorteningStrategies::RedisCounterStrategy.new(custom_redis_config)
     class RedisCounterStrategy < BaseStrategy
-      begin
-        require 'redis'
-      rescue LoadError
-        raise 'Missing dependency: Please add "redis" to your Gemfile to use RedisCounterStrategy.'
-      end
-
       MIN_LENGTH = 12
       REDIS_COUNTER_KEY = "dynamic_links:counter".freeze
 
-      def initialize
-        # TODO: use pool of connections
-        @redis = Redis.new
+      # @param redis_config [Hash]
+      def initialize(redis_config = nil)
+        super()
+
+        configuration = redis_config.nil? ? DynamicLinks.configuration.redis_counter_config : DynamicLinks::Configuration::RedisConfig.new(redis_config)
+        @redis = ConnectionPool.new(size: configuration.pool_size, timeout: configuration.pool_timeout) do
+          Redis.new(configuration.config)
+        end
+      end
+
+      def always_growing?
+        true  # This strategy always generates a new shortened URL
       end
 
       # Shortens the given URL using a Redis counter
       # @param url [String] The URL to shorten
       # @return [String] The shortened URL, 12 characters long
       def shorten(url, min_length: MIN_LENGTH)
-        counter = @redis.incr(REDIS_COUNTER_KEY)
-
-        short_url = base62_encode("#{counter}#{url.hash.abs}".to_i)
-        short_url.ljust(min_length, '0')
+        @redis.with do |conn|
+          counter = conn.incr(REDIS_COUNTER_KEY)
+          short_url = base62_encode("#{counter}#{url.hash.abs}".to_i)
+          short_url = short_url.ljust(min_length, '0')
+          short_url
+        end
       end
     end
   end

data/lib/dynamic_links/strategy_factory.rb

@@ -1,5 +1,8 @@
 module DynamicLinks
   class StrategyFactory
+    VALID_SHORTENING_STRATEGIES = [:md5, :sha256, :crc32,
+                                   :nano_id, :redis_counter, :mock].freeze
+
     def self.get_strategy(strategy_name)
       case strategy_name
       when :md5
@@ -9,8 +12,10 @@ module DynamicLinks
       when :crc32
         ShorteningStrategies::CRC32Strategy.new
       when :nano_id
-        ShorteningStrategies::NanoIdStrategy.new
+        ensure_nanoid_available
+        ShorteningStrategies::NanoIDStrategy.new
       when :redis_counter
+        ensure_redis_available
         ShorteningStrategies::RedisCounterStrategy.new
       when :mock
         ShorteningStrategies::MockStrategy.new
@@ -18,6 +23,28 @@ module DynamicLinks
         raise "Unknown strategy: #{strategy_name}"
       end
     end
+
+    def self.ensure_nanoid_available
+      begin
+        require 'nanoid'
+      rescue LoadError
+        raise 'Missing dependency: Please add "nanoid" to your Gemfile to use NanoIdStrategy.'
+      end
+    end
+
+    def self.ensure_redis_available
+      begin
+        require 'redis'
+      rescue LoadError
+        raise 'Missing dependency: Please add "redis" to your Gemfile to use RedisCounterStrategy.'
+      end
+
+      begin
+        require 'connection_pool'
+      rescue LoadError
+        raise 'Missing dependency: Please add "connection_pool" to your Gemfile to use RedisCounterStrategy.'
+      end
+    end
   end
 end
 

data/lib/dynamic_links/validator.rb

@@ -0,0 +1,14 @@
+module DynamicLinks
+  class Validator
+    # Validates if the given URL is a valid HTTP or HTTPS URL
+    # @param url [String] The URL to validate
+    # @return [Boolean] true if valid, false otherwise
+    def self.valid_url?(url)
+      uri = URI.parse(url)
+      uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end
+

data/lib/dynamic_links/version.rb

@@ -1,3 +1,3 @@
 module DynamicLinks
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/dynamic_links.rb

@@ -1,5 +1,31 @@
+# @author Saiqul Haq <saiqulhaq@gmail.com>
+
+if ENV['RAILS_ENV'] == 'test'
+  require 'simplecov'
+
+  SimpleCov.start do
+    load_profile "test_frameworks"
+
+    add_filter %r{^/config/}
+    add_filter %r{^/db/}
+
+    add_group "Controllers", "app/controllers"
+    add_group "Channels", "app/channels"
+    add_group "Models", "app/models"
+    add_group "Mailers", "app/mailers"
+    add_group "Helpers", "app/helpers"
+    add_group "Jobs", %w[app/jobs app/workers]
+    add_group "DynamicLinks", "lib/"
+  end
+end
+
 require "dynamic_links/version"
 require "dynamic_links/engine"
+require "dynamic_links/logger"
+require "dynamic_links/error_classes"
+require "dynamic_links/redis_config"
+require "dynamic_links/configuration"
+require "dynamic_links/validator"
 require "dynamic_links/strategy_factory"
 require "dynamic_links/shortening_strategies/base_strategy"
 require "dynamic_links/shortening_strategies/sha256_strategy"
@@ -8,7 +34,8 @@ require "dynamic_links/shortening_strategies/crc32_strategy"
 require "dynamic_links/shortening_strategies/nano_id_strategy"
 require "dynamic_links/shortening_strategies/redis_counter_strategy"
 require "dynamic_links/shortening_strategies/mock_strategy"
-require "dynamic_links/configuration"
+require "dynamic_links/async/locker"
+require "dynamic_links/shortener"
 
 module DynamicLinks
   class << self
@@ -23,26 +50,20 @@ module DynamicLinks
     end
   end
 
-  def self.shorten_url(url)
-    strategy_key = configuration.shortening_strategy
-
-    begin
-      strategy = StrategyFactory.get_strategy(strategy_key)
-    rescue RuntimeError => e
-      # This will catch the 'Unknown strategy' error from the factory
-      raise "Invalid shortening strategy: #{strategy_key}. Error: #{e.message}"
-    rescue ArgumentError
-      raise "#{strategy_key} strategy needs to be initialized with arguments"
-    rescue => e
-      raise "Unexpected error while initializing the strategy: #{e.message}"
-    end
+  def self.shorten_url(url, client, async: DynamicLinks.configuration.async_processing)
+    raise InvalidURIError, 'Invalid URL' unless Validator.valid_url?(url)
 
-    strategy.shorten(url)
+    shortener = Shortener.new
+    if async
+      shortener.shorten_async(client, url)
+    else
+      shortener.shorten(client, url)
+    end
   end
 
   # mimic Firebase Dynamic Links API
-  def self.generate_short_url(original_url)
-    short_link = shorten_url(original_url)
+  def self.generate_short_url(original_url, client)
+    short_link = shorten_url(original_url, client)
 
     {
       shortLink: short_link,
@@ -50,4 +71,20 @@ module DynamicLinks
       warning: []
     }
   end
+
+  def self.resolve_short_url(short_link)
+    DynamicLinks::ShortenedUrl.find_by(short_url: short_link)&.url
+  end
+
+  def self.find_short_link(long_url, client)
+    short_link = DynamicLinks::ShortenedUrl.find_by(url: long_url, client_id: client.id)
+    if short_link
+      {
+        short_url: "#{client.scheme}://#{client.hostname}/#{short_link.short_url}",
+        full_url: long_url
+      }
+    else
+      nil
+    end
+  end
 end