mozaik 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9795fb07d8cc2cd835fef4ff248de49f0d2d589ffbbb9882c915913aada3543a
+  data.tar.gz: 280f6e3a28ca194b8b85bd92362b8600fb78fcbdcc34a4afb0bcb25e4acf0d9d
+SHA512:
+  metadata.gz: '0969c0cc189968e3d00f322438495f405b89565a0aa9f487e4ea192cea888bad65d59d1ceec74e756da22fba1d22235b8531fdb3a2521c2bc1f746ab8631b2d5'
+  data.tar.gz: 1ca4478c06dd430a0145ca4ad3d029b8e65958997124e68950135823abe241b18cb2fc8569f18436969e977c1b4b6edf3476a66572d107ac7520308d5a58c11e

data/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+
+on: [push]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        bundler-cache: true
+
+    - name: Test
+      run: bundle exec rspec

data/.gitignore

@@ -0,0 +1,43 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+.rspec_status
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yaml

@@ -0,0 +1,98 @@
+require: rubocop-rspec
+AllCops:
+  TargetRubyVersion: 3.1.2
+  DisplayCopNames: true
+  Exclude:
+    - 'bin/*'
+    - 'db/schema.rb'
+    - 'vendor/**/*'
+    - 'node_modules/**/*'
+    - '**/*.rake'
+    - 'licenses/*'
+
+Documentation:
+  Enabled: false
+
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: true
+  Max: 120
+
+Metrics/BlockLength:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*.rb'
+    - config/routes.rb
+
+Style/Documentation:
+  Enabled: false
+
+# This rule enforces the same delimiters to be used everywhere for %-literals.
+# Each type of %-literal can be configured to use it's own specific notation when needed.
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%':  ()
+    '%i': ()
+    '%q': ()
+    '%Q': ()
+    '%r': '{}'
+    '%s': ()
+    '%w': ()
+    '%W': ()
+    '%x': ()
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+# This rule ensures that all Regex expression are written using the same style.
+# The current configuration will be inline with the string array where %w is forced.
+Style/RegexpLiteral:
+  EnforcedStyle: percent_r
+  AllowInnerSlashes: false
+
+RSpec/MessageSpies:
+  EnforcedStyle: receive
+
+RSpec/NestedGroups:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Layout/EmptyLineAfterGuardClause:
+  Enabled: true
+
+Naming/PredicateName:
+  Enabled: true
+
+Style/EmptyLiteral:
+  Enabled: true
+
+Style/ExpandPathArguments:
+  Enabled: true
+
+Style/NumericLiterals:
+  Enabled: true
+
+Style/WordArray:
+  Enabled: true
+
+Layout/ClosingHeredocIndentation:
+  Enabled: true
+
+RSpec/EmptyLineAfterExampleGroup:
+  Enabled: true
+
+Style/RandomWithOffset:
+  Enabled: true
+
+Style/WhileUntilModifier:
+  Enabled: true

data/.ruby-version

@@ -0,0 +1 @@
+3.3.8

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mozaik.gemspec
+gemspec
+
+group :development do
+  gem 'pry', platforms: [:mri]
+  gem 'rspec'
+  gem 'rubocop'
+  gem 'rubocop-rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,125 @@
+PATH
+  remote: .
+  specs:
+    mozaik (1.0.0)
+      activesupport
+      dry-struct (>= 1.0, < 2.0)
+      dry-types (>= 1.0, < 2.0)
+      i18n
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (8.0.2)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ast (2.4.2)
+    base64 (0.3.0)
+    benchmark (0.4.1)
+    bigdecimal (3.2.2)
+    coderay (1.1.3)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.3)
+    diff-lcs (1.5.0)
+    drb (2.2.3)
+    dry-core (1.1.0)
+      concurrent-ruby (~> 1.0)
+      logger
+      zeitwerk (~> 2.6)
+    dry-inflector (1.2.0)
+    dry-logic (1.6.0)
+      bigdecimal
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.1)
+      zeitwerk (~> 2.6)
+    dry-struct (1.8.0)
+      dry-core (~> 1.1)
+      dry-types (~> 1.8, >= 1.8.2)
+      ice_nine (~> 0.11)
+      zeitwerk (~> 2.6)
+    dry-types (1.8.3)
+      bigdecimal (~> 3.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0)
+      dry-inflector (~> 1.0)
+      dry-logic (~> 1.4)
+      zeitwerk (~> 2.6)
+    i18n (1.14.7)
+      concurrent-ruby (~> 1.0)
+    ice_nine (0.11.2)
+    json (2.6.3)
+    logger (1.7.0)
+    method_source (1.0.0)
+    minitest (5.25.5)
+    parallel (1.22.1)
+    parser (3.2.1.0)
+      ast (~> 2.4.1)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.1.1)
+    regexp_parser (2.7.0)
+    rexml (3.3.6)
+      strscan
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.45.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.26.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.17.0)
+      rubocop (~> 1.41)
+    rubocop-rspec (2.18.1)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
+    ruby-progressbar (1.11.0)
+    securerandom (0.4.1)
+    strscan (3.1.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+    uri (1.0.3)
+    zeitwerk (2.7.3)
+
+PLATFORMS
+  arm64-darwin-24
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  mozaik!
+  pry
+  rspec
+  rubocop
+  rubocop-rspec
+
+BUNDLED WITH
+   2.4.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Hive Technologies
+
+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,314 @@
+# Mozaik::Service
+
+This gem aims to simplify and standardize the service interface to be used across the service layer in our ruby projects. It provides composition, typing, and built in validations to ensure that our complex service logic is both flexible and safe.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mozaik'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mozaik
+
+To install the gem locally you need to have your bundle configured to fetch from our org's private repos. Follow the following steps to do so:
+1. Go to your github settings -> Developer settings -> Personal access tokens
+2. Create a new token and check the repo permissions
+3. Save your token somewhere
+4. On your local machine use the following command:
+```bash
+$ bundle config github.com 'YOUR_TOKEN_HERE'
+```
+5. Restart your terminal session and bundling should work as expected!
+
+## Usage
+
+We need to create a base service that will inherit from `::Mozaik::Service`:
+
+```ruby
+class BaseService < ::Mozaik::Service
+
+end
+```
+
+## .run
+
+Example:
+
+```ruby
+class ExampleService < BaseService
+  attribute :counter, type: Types::Integer, required: true
+
+  validate :counter_not_exceeded
+
+  def perform
+    @counter + 1
+  end
+
+  private
+
+  def counter_not_exceeded
+    add_error(:counter, :exceeded) if @counter > 10
+  end
+end
+```
+
+Usage:
+```ruby
+ExampleService.run(counter: 9)
+
+=> Mozaik::Service::Result.new(result: 10, errors: nil, success: true)
+```
+
+The following happens:
+- It will validate that the counter can be coerced in to integer
+- If not, execution will be halted and service will fail
+- It will run `counter_not_exceeded` method (if validation passes)
+- If the validation fails (counter > 10), `perform` method will not be executed and the service will **fail**
+- If the validation passes `perform` method will be executed
+- `Result` object will be returned with `success=true` and `result=counter+1`
+
+Note that:
+```ruby
+ExampleService.run('counter' => 9)
+```
+
+is also a valid service invocation
+
+## .run!
+
+The `run!` method will raise an error `Mozaik::Service::Failure` if validation fails, otherwise it will return the returned value from the `perform` method without wrapping it in a `Result` object.
+
+`Mozaik::Service::Failure` will have access to errors:
+
+```ruby
+begin
+ ExampleService.run!('counter' => 11)
+rescue Mozaik::Service::Failure => error
+  error.errors.to_h
+end
+
+=> { counter: [type: :exceeded] }
+
+```
+
+## #compose
+
+The `compose` method allows us to compose multiple services within a service.
+
+Usage:
+
+```ruby
+def perform
+  counter = @counter + 10
+  new_counter = compose AnotherService, counter: counter, other_param: true
+  new_counter + counter
+end
+```
+
+It will:
+
+- Call `AnotherService.run()` with given attributes
+- If composed service fails **it will halt whole execution** and merge the errors with calling service's errors.
+- If composed service succeeds it will return the unwrapped return value of the composed service's `perform` method
+
+## Result object
+
+Running the `run` method causes the service to return a `Result` object.
+
+If the service succeeds:
+- `Result` object will have `success=true`
+- `Result` object will have returned value from `perform` method inside `result` attribute
+- `Result` object will have empty `errors`
+
+If the service fails:
+- `Result` object will have `success=false`
+- `Result` object will have `result=nil`
+- `Result` object will have one or more errors in the `errors` attribute
+
+## Errors
+
+Each instance of this class will have `@errors`. At any point for lifecycle you can add errors.
+After each step (validations, execution) service will check if there are some errors - if yes it will halt execution and return `Result` object
+
+to add error use `add_error` method:
+
+```ruby
+add_error(:some_field, :this_is_an_error)
+```
+
+Note: this will add error but will not halt current step
+
+To add error and halt execution immediately use:
+
+```ruby
+add_error!(:some_field, :this_is_error)
+```
+
+## Errors object
+
+Errors object is similar to hash but with some adjustments.
+If you only care about error values then you can run `#to_h`.
+If you want also full messages or the translations then run `#full_details`.
+
+It will return a hash similar to:
+
+```ruby
+{
+  counter: {
+    type: :exceeded,
+    message: 'Counter was exceeded'
+  }
+}
+```
+
+This gem uses `I18n` for translation, it will look for a translation key as follows:
+`[service_name].errors.[some_attribute].[error_name]`.
+
+The `[service_name]` is the class of service name converted to under score like:
+
+`SomeNamespace::SomeModule::ExampleService` -> `some_namespace.some_module.some_service`
+
+For errors coming from composed services, it will try to find translation for **outer** (caller) service first
+and then for **inner** (composed) service.
+
+## Attributes
+
+Attributes are validated/coerced using `Dry::Types`.
+
+To define a type for an attribute use:
+```ruby
+attribute :some_attribute, type: Types::[some-type]
+```
+
+If the passed value has a different type the service will fail and add an error:
+```ruby
+ errors.add(:some_attribute, :wrong_type)
+```
+
+The value will be accessible by an **instance variable**: `@some_attribute`
+
+So for example:
+
+```ruby
+attribute :cool_attribute, type: Types::Integer
+
+def perform
+  @cool_attribute + 1
+end
+```
+
+It will be accessible by an instance method you define inside your service class.
+
+By default `Types` module has imported coercible types, if you want to use strict ones (that will raise error if passed attribute does not have exactly same type) you need to call it explicitly by using `Strict`:
+
+```ruby
+attribute :some_attribute, type: Types::Strict::[some-type]
+```
+
+By default every attribute is **not required**. You can change that by passing `required: true` option to the attribute
+
+```ruby
+attribute :some_attribute, type: Types::String, required: true
+```
+
+In this case, if `some_attribute` will be missing service will add an error:
+
+```ruby
+ errors.add(:some_attribute, :blank)
+```
+
+You can also specify a default value for given attribute:
+
+```ruby
+attribute :some_attribute, type: Types::String, default: 'this is the default value'
+```
+
+If `some_attribute` will not be passed to service it will use the defined default value. _Default values will be coerced_.
+
+
+### Basic types
+
+|type|example coercion|
+|---|---|
+|Types::String| `123 -> '123'`, `:symbol -> 'symbol'`|
+|Types::Symbol| `'symbol' -> :symbol`|
+|Types::Integer| `'123' -> 123`, `123.13 -> 123`|
+|Types::Float| `'123.123' -> 123.123`, `123 -> 123.0`|
+|Types::Date| `'2010-10-10' -> Date.parse('2010-10-10')`|
+|Types::Time| `'2010-10-10 10:10' -> Time.parse('2010-10-10 10:10')`|
+|Types::Bool| `'false' -> false`, `'1' -> true`|
+
+### Instance type
+
+Instance can be used in two ways:
+1) Pure `dry-types`
+2) Pure class
+
+|type|example|
+|---|---|
+|Types::Instance(SomeType) | `SomeType.new` |
+|SomeType | `SomeType.new` |
+
+The gem will wrap anything passed as `type` of attribute which is not a child of `Dry::Types::Type` (or `Array`) into `Types::Instance()`
+
+### Array type
+
+Array can be used in two ways:
+1) Pure `dry-types`
+2) Wrapped in syntax sugar
+
+|type|example|
+|---|---|
+|`Types::Array(Types::Symbol)` | `[:symbol, 'other-symbol']` |
+|`[Types::Symbol]` | `[:symbol, 'other-symbol']` |
+|`[SomeType]` | `[SomeType.new]` |
+|`Types::Array(Types::Instance(SomeType))` | `[SomeType.new]` |
+
+Using syntax sugar will allow us to pass normal classes inside `[]` and this classes will be wrapped into
+`Types::Instance()`
+
+### Interface type
+
+Interface type should be used with `dry-type` `Interface` syntax:
+
+```ruby
+attribute :some_attribute, type: Types::Interface(:some_method)
+```
+
+### Hash type
+
+Interface type should be used with `dry-type` `Hash` sytnax:
+
+```ruby
+attribute :some_attribute, type: Types::Hash(some_key: Types::Integer)
+```
+
+Note if you want to use classes for nested types then you need to wrap it into `Types::Instance()`
+
+### Any type
+
+Any type should be used with `dry-type` `Any` syntax:
+
+```ruby
+attribute :some_attribute, type: Types::Any
+```
+
+> The use of `Any` type should be limited as much as possible since it contradicts the whole concept of typing in the first place!
+
+### Any any type
+
+You can use any type that comes from `dry-types`. For reference please see: [dry-types](https://dry-rb.org/gems/dry-types/1.2/built-in-types/)
+
+### Examples
+
+You can find implementation examples in `spec/mozaik/service_spec.rb`
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'mozaik/service'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mozaik/service/attribute_value.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mozaik
+  class Service
+    class AttributeValue
+      AttributeBlank = Class.new(StandardError)
+      AttributeWithWrongType = Class.new(StandardError)
+
+      def initialize(value, options)
+        @value = value
+        @options = options
+      end
+
+      def call
+        value = @value
+        value = @options[:default] if value.nil? && @options.key?(:default)
+        type[value]
+      rescue Dry::Types::CoercionError, Dry::Types::MissingKeyError, Dry::Types::SchemaError
+        raise AttributeBlank if @value.nil? && @options[:required]
+
+        raise AttributeWithWrongType
+      end
+
+      def type
+        return @type if @type
+
+        @type = determine_type(@options[:type])
+        @type = @type.optional unless @options[:required]
+        @type
+      end
+
+      def determine_type(type)
+        case type
+        when Dry::Types::Type
+          type
+        when Array
+          Types::Array(determine_type(type.first))
+        else
+          Types.Instance(type)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/mozaik/service/errors.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Mozaik
+  class Service
+    class Errors
+      def initialize(service)
+        @service_class = service.class
+        @errors = {}
+        @error_sources = {}
+      end
+
+      def add(name, type)
+        return self if error?(name, type)
+
+        name = name.to_sym
+        @error_sources[name] ||= {}
+        @error_sources[name][type] = @service_class
+
+        @errors[name] ||= []
+        @errors[name] << { type: type.to_sym }
+
+        self
+      end
+
+      def [](key)
+        @errors[key]
+      end
+
+      def ==(other)
+        to_h == other.to_h
+      end
+
+      def to_h
+        @errors
+      end
+
+      def empty?
+        @errors.empty?
+      end
+
+      def error?(name, type)
+        (self[name.to_sym] || []).any? { |error| error.fetch(:type) == type.to_sym }
+      end
+
+      def inspect
+        "#{self.class} #{@errors}"
+      end
+
+      def merge(other)
+        merge_errors(other.errors)
+        merge_error_sources(other.error_sources)
+        self
+      end
+
+      def full_details
+        @errors.map do |key, errors|
+          [key, errors.map { |error| { type: error[:type], message: translate_error(key, error[:type]) } }]
+        end.to_h
+      end
+
+      def as_json(_options)
+        to_h
+      end
+
+      protected
+
+      attr_reader :errors, :error_sources
+
+      private
+
+      def merge_errors(other_errors)
+        other_errors.each do |name, errors|
+          @errors[name] ||= []
+          @errors[name] = (@errors[name] + errors).uniq
+        end
+      end
+
+      def merge_error_sources(other_error_sources)
+        @error_sources = @error_sources.deep_merge(other_error_sources)
+      end
+
+      def translate_error(key, type)
+        original_service_class = @error_sources[key][type]
+        [@service_class, original_service_class]
+          .uniq
+          .map { |service_class| translate(key, type, service_class) }
+          .select(&:itself)
+          .first
+      end
+
+      def translate(name, type, service_class)
+        prefix = service_class.to_s.underscore.tr('/', '.')
+        key = [prefix, 'errors', name, type].join('.')
+        I18n.exists?(key) && I18n.t(key)
+      end
+    end
+  end
+end
+
+

data/lib/mozaik/service/failure.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mozaik
+  class Service
+    class Failure < StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        super
+        @errors = errors
+      end
+
+      def message
+        "failed with errors #{errors.to_h}"
+      end
+    end
+  end
+end
+
+

data/lib/mozaik/service/result.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mozaik
+  class Service
+    class Result < Dry::Struct
+      attribute :success, Types::Bool
+      attribute :result, Types::Any
+      attribute :errors, Types.Instance(Errors) | Types::Nil
+
+      def success?
+        success
+      end
+
+      def failure?
+        !success
+      end
+
+      def successful?
+        success
+      end
+    end
+  end
+end
+
+

data/lib/mozaik/service/types.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Mozaik
+  class Service
+    module Types
+      # Expose Dry types with coercible defaults matching original behavior
+      include Dry.Types(default: :params)
+
+      Any = Nominal::Any
+      String = Coercible::String
+      Symbol = Coercible::Symbol
+      Integer = Coercible::Integer
+      Float = Coercible::Float
+      Date = Params::Date
+      Time = Params::Time
+      Bool = Params::Bool
+      Class = Strict::Class
+    end
+  end
+end
+
+

data/lib/mozaik/service/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Mozaik
+  class Service
+    VERSION = '1.0.0'
+  end
+end
+
+

data/lib/mozaik/service.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+require 'dry-struct'
+require 'i18n'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
+
+require 'mozaik/service/version'
+require 'mozaik/service/errors'
+require 'mozaik/service/types'
+require 'mozaik/service/result'
+require 'mozaik/service/failure'
+require 'mozaik/service/attribute_value'
+
+module Mozaik
+  class Service
+    class Halt < StandardError; end
+
+    def self.attribute(name, type:, required: false, default: nil)
+      @attributes ||= {}
+      @attributes[name] = { type: type, required: required, default: default }
+    end
+
+    def self.attributes
+      @attributes || {}
+    end
+
+    def self.attributes_names
+      attributes.keys
+    end
+
+    def self.validations
+      @validations ||= []
+    end
+
+    def self.validate(method, *args)
+      validations.push([method, args]) unless validations.include?([method, args])
+    end
+
+    def self.run(attributes = {})
+      new(attributes).run
+    end
+
+    def self.run!(attributes = {})
+      outcome = run(attributes)
+      raise Failure, outcome.errors unless outcome.success?
+
+      outcome.result
+    end
+
+    def initialize(attributes = {})
+      initialize_errors
+      initialize_inputs(attributes)
+      initialize_attributes
+    end
+
+    def run
+      halt! unless valid?
+      validate
+      halt! unless valid?
+      result = perform
+      halt! unless valid?
+      return_success(result)
+    rescue Halt
+      return_failure(@errors)
+    end
+
+    private
+
+    def compose(other_service_class, params = {})
+      outcome = other_service_class.run(params)
+      return outcome.result if outcome.success?
+
+      @errors.merge(outcome.errors)
+      halt!
+    end
+
+    def add_error(name, error)
+      @errors.add(name, error)
+    end
+
+    def add_error!(name, error)
+      add_error(name, error)
+      halt!
+    end
+
+    def validate
+      self.class.validations.each { |method, _| send(method) }
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def halt!
+      raise Halt
+    end
+
+    def return_success(result)
+      Result.new(result: result, success: true, errors: nil)
+    end
+
+    def return_failure(errors)
+      Result.new(result: nil, success: false, errors: errors)
+    end
+
+    def initialize_errors
+      @errors = Errors.new(self)
+    end
+
+    def initialize_inputs(attributes)
+      @inputs = attributes.deep_symbolize_keys
+    end
+
+    def initialize_attributes
+      self.class.attributes.each { |name, options| initialize_attribute(name, options) }
+    end
+
+    def initialize_attribute(name, options)
+      value = AttributeValue.new(@inputs[name], options).call
+
+      instance_variable_set(:"@#{name}", value)
+    rescue AttributeValue::AttributeBlank
+      @errors.add(name, :blank)
+    rescue AttributeValue::AttributeWithWrongType
+      @errors.add(name, :wrong_type)
+    end
+  end
+end
+
+

data/mozaik.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mozaik/service/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mozaik'
+  spec.version       = Mozaik::Service::VERSION
+  spec.authors       = ['Mohamed Elmenisy']
+  spec.email         = ['mohamed.elmenisy@hive.app']
+
+  spec.summary       = 'Service layer abstraction'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'dry-struct', '>= 1.0', '< 2.0'
+  spec.add_runtime_dependency 'dry-types', '>= 1.0', '< 2.0'
+  spec.add_runtime_dependency 'i18n'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: mozaik
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mohamed Elmenisy
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description:
+email:
+- mohamed.elmenisy@hive.app
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yaml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mozaik/service.rb
+- lib/mozaik/service/attribute_value.rb
+- lib/mozaik/service/errors.rb
+- lib/mozaik/service/failure.rb
+- lib/mozaik/service/result.rb
+- lib/mozaik/service/types.rb
+- lib/mozaik/service/version.rb
+- mozaik.gemspec
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Service layer abstraction
+test_files: []