blueprinter_schema 0.6.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b10fc12e29b6f54a7f5515b3d97809bd65e1fded8acd99a2d9395339cf7b1b2c
-  data.tar.gz: 4f0403c88c922e8c026d4ac0b7dd686c1e88f7f0f3fcde3174f184bfb9e375b9
+  metadata.gz: 9246edd433fe3a71df7924c38bfd92928af95ddfdc90aebab7285ed6270e3fdc
+  data.tar.gz: 228234c8612cdf7e8b728e67974831263bc077864ea6ec0f0608d6c23c8cbe8b
 SHA512:
-  metadata.gz: ac1dd30628176e9f5feb4f461bd4a4931050967945be9f81e1e6ceaa4387f52c1139d652a518acf4b2bce5e5309d9c95ccd8d5708215c672975b730e9be20e57
-  data.tar.gz: f77ef5d6d8c7d3c8a204f5b053b7a56183c3298f6b8b6a22606257e16febb0087ccb304ad60ed7acd26f3123693b40756503b178096870fd80d705d604f737e6
+  metadata.gz: e1d5833548d59cb364765ea3db2bee8c50c13fadb12bd18e742014e48c8636de6a1ef4519ab79ac8c194b3301fa5dc9b0f9cdd61da70383d052e50687619a496
+  data.tar.gz: 3e731df8e7f2ac8736fda0fdcd40797b6ec024297cb186c255e71087fdb9a6a9db365517c5dd9fb25a24ea5f128c2c49b5e1aebef1fd83f8ecd500f22fc82d23

data/.rubocop.yml

@@ -9,3 +9,7 @@ AllCops:
 # Do not enforce documentation
 Style/Documentation:
   Enabled: false
+
+# Matching big hashes
+RSpec/ExampleLength:
+  Enabled: false

data/README.md

@@ -1,8 +1,6 @@
 # BlueprinterSchema
 
-### Create JSON Schema from [Blueprinter](https://github.com/procore-oss/blueprinter) Serializers and ActiveRecord Models.
-
-Serializers define which fields are used. Models know the database field types. Put these together and you get a JSON Schema.
+#### Create JSON Schemas from [Blueprinter](https://github.com/procore-oss/blueprinter) Serializers.
 
 ## Installation
 
@@ -14,35 +12,54 @@ gem "blueprinter_schema"
 
 ## Usage
 
-With the folloing Models and Serializers:
 ```rb
-class Address < ApplicationRecord
-  belongs_to :user
+class UserSerializer < Blueprinter::Base
+  field :first_name, type: [:string, :null]
+  field :last_name, type: [:string, :null]
+  field :full_name, type: [:string, :null], description: "The concatendated first and last name."
+  field :email, type: :string, format: :email
 end
 
-class User < ApplicationRecord
-  has_many :addresses
-end
+BlueprinterSchema.generate(serializer: UserSerializer)
+```
 
-class AddressSerializer < Blueprinter::Base
-  identifier :id
+```rb
+{
+  "type" => "object",
+  "properties" => {
+    "first_name" => {
+      "type" => ["string", "null"]
+    },
+    "last_name" => {
+      "type" => ["string", "null"]
+    },
+    "full_name" => {
+      "type" => ["string", "null"],
+      "description" => "The concatendated first and last name."
+    },
+    "email" => {
+      "type" => "string",
+      "format" => "email"
+    }
+  },
+  "required" => ["first_name", "last_name", "full_name", "email"],
+  "additionalProperties" => false
+}
+```
 
-  field :address
-end
+You can pass an ActiveRecord Model to automatically infer types from DB fields:
 
+```rb
 class UserSerializer < Blueprinter::Base
-  identifier :id
-
-  field :name, description: 'The name of the user'
-  fields :email, :created_at
+  field :first_name
+  field :last_name
+  field :email
+end
 
-  association :addresses, blueprint: AddressSerializer
+class User < ApplicationRecord
 end
-```
 
-Generate JSON Schema:
-```rb
-BlueprinterSchema.generate(UserSerializer, User)
+BlueprinterSchema.generate(serializer: UserSerializer, model: User)
 ```
 
 ```rb
@@ -50,38 +67,74 @@ BlueprinterSchema.generate(UserSerializer, User)
   "type" => "object",
   "title" => "User",
   "properties" => {
-    "id" => {
-      "type" => "integer"
+    "first_name" => {
+      "type" => ["string", "null"]
     },
-    "created_at" => {
-      "type" => "string", "format" => "date-time"
+    "last_name" => {
+      "type" => ["string", "null"]
     },
     "email" => {
       "type" => "string"
-    },
-    "name" => {
-      "type" => ["string", "null"],
-      'description' => 'The name of the user'
+    }
+  },
+  "required" => ["first_name", "last_name", "email"],
+  "additionalProperties" => false
+}
+```
+
+You can use associations:
+
+```rb
+class UserSerializer < Blueprinter::Base
+  field :email, type: :string
+
+  association :addresses, blueprint: AddressSerializer, collection: true
+  association :profile, blueprint: ProfileSerializer
+end
+
+class AddressSerializer < Blueprinter::Base
+  field :address, type: :string
+end
+
+class ProfileSerializer < Blueprinter::Base
+  field :public, type: :boolean
+end
+
+BlueprinterSchema.generate(serializer: UserSerializer)
+```
+
+```rb
+{
+  "type" => "object",
+  "properties" => {
+    "email" => {
+      "type" => "string"
     },
     "addresses" => {
       "type" => "array",
       "items" => {
         "type" => "object",
-        "title" => "Address",
         "properties" => {
-          "id" => {
-            "type" => "integer"
-          },
           "address" => {
             "type" => "string"
           }
         },
-        "required" => ["id", "address"],
+        "required" => ["address"],
         "additionalProperties" => false
       }
+    },
+    "profile" => {
+      "type" => "object",
+      "properties" => {
+        "public" => {
+          "type" => "boolean"
+        }
+      },
+      "required" => ["public"],
+      "additionalProperties" => false
     }
   },
-  "required" => ["id", "created_at", "email", "name"],
+  "required" => ["email", "addresses", "profile"],
   "additionalProperties" => false
 }
 ```
@@ -90,13 +143,11 @@ BlueprinterSchema.generate(UserSerializer, User)
 
 ```rb
 BlueprinterSchema.generate(
-  serializer,
-  model,
-  {
-    include_conditional_fields: true, # Whether or not to include conditional fields from the serializer
-    fallback_type: {}, # Type when no DB column is found or type is unknown. E.g. { 'type' => 'object' }
-    view: :default # The Blueprint view to use
-  }
+  serializer:,
+  model: nil,
+  include_conditional_fields: true, # Whether or not to include conditional fields from the serializer
+  fallback_type: {}, # Type when no DB column or type definition is found. E.g. { 'type' => 'object' }
+  view: :default # The blueprint view to use
 )
 ```
 

data/lib/blueprinter_schema/generator.rb

@@ -1,31 +1,39 @@
 # frozen_string_literal: true
 
 module BlueprinterSchema
+  class InvalidJsonSchemaType < StandardError; end
+
+  # rubocop:disable Metrics/ClassLength
   class Generator
-    def initialize(serializer, model, options)
+    def initialize(serializer:, model:, skip_conditional_fields:, fallback_definition:, view:)
       @serializer = serializer
       @model = model
-      @options = options
+      @skip_conditional_fields = skip_conditional_fields
+      @fallback_definition = fallback_definition
+      @view = view
     end
 
     def generate
-      {
+      schema = {
         'type' => 'object',
-        'title' => @model.name,
         'properties' => build_properties,
         'required' => build_required_fields,
         'additionalProperties' => false
       }
+
+      schema['title'] = @model.name if @model
+
+      schema
     end
 
     private
 
     def fields
-      @fields ||= @serializer.reflections[@options[:view]].fields
+      @fields ||= @serializer.reflections[@view].fields
     end
 
     def associations
-      @associations ||= @serializer.reflections[@options[:view]].associations
+      @associations ||= @serializer.reflections[@view].associations
     end
 
     def build_properties
@@ -45,20 +53,41 @@ module BlueprinterSchema
     end
 
     def skip_field?(field)
-      !@options[:include_conditional_fields] &&
-        (field.options[:if] || field.options[:unless] || field.options[:exclude_if_nil])
+      @skip_conditional_fields && (field.options[:if] || field.options[:unless])
     end
 
     def build_required_fields
-      fields.reject { |_, field| skip_field?(field) }.keys.map(&:to_s)
+      fields
+        .reject { |_, field| field.options[:exclude_if_nil] }
+        .reject { |_, field| skip_field?(field) }
+        .keys.map(&:to_s)
     end
 
+    # rubocop:disable Metrics/AbcSize
     def field_to_json_schema(field)
-      column = @model.columns_hash[field.name.to_s]
+      type_definition = @fallback_definition.dup
 
-      type = ar_column_to_json_schema(column) || @options[:fallback_type]
-      type['description'] = field.options[:description] if field.options[:description]
-      type
+      if field.options[:type]
+        type_definition['type'] = ensure_valid_json_schema_types!(field)
+      elsif @model
+        column = @model.columns_hash[field.name.to_s]
+        type_definition = ar_column_to_json_schema(column)
+      end
+
+      type_definition['format'] = field.options[:format] if field.options[:format]
+      type_definition['description'] = field.options[:description] if field.options[:description]
+      type_definition
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def ensure_valid_json_schema_types!(field)
+      types = [field.options[:type]].flatten.map(&:to_s)
+
+      return field.options[:type] if types.all? do |type|
+        %w[string integer number boolean object array null].include?(type)
+      end
+
+      raise BlueprinterSchema::InvalidJsonSchemaType, "Invalid type: #{field.options[:type]}"
     end
 
     # rubocop:disable Metrics/MethodLength
@@ -95,13 +124,23 @@ module BlueprinterSchema
 
       return { 'type' => 'object' } unless blueprint_class
 
-      ar_association = @model.reflect_on_association(association.name)
-      is_collection = ar_association.collection?
-      association_model = ar_association.klass
+      ar_association = @model&.reflect_on_association(association.name)
+      is_collection = ar_association ? ar_association.collection? : association.options[:collection]
 
-      associated_schema = BlueprinterSchema.generate(blueprint_class, association_model)
+      associated_schema = recursive_generate(blueprint_class, ar_association&.klass)
 
       is_collection ? { 'type' => 'array', 'items' => associated_schema } : associated_schema
     end
+
+    def recursive_generate(serializer, model)
+      BlueprinterSchema.generate(
+        serializer:,
+        model:,
+        skip_conditional_fields: @skip_conditional_fields,
+        fallback_definition: @fallback_definition,
+        view: @view
+      )
+    end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/blueprinter_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BlueprinterSchema
-  VERSION = '0.6.0'
+  VERSION = '1.0.1'
 end

data/lib/blueprinter_schema.rb

@@ -5,10 +5,12 @@ require_relative 'blueprinter_schema/generator'
 
 module BlueprinterSchema
   def self.generate(
-    serializer,
-    model,
-    options = { include_conditional_fields: true, fallback_type: {}, view: :default }
+    serializer:,
+    model: nil,
+    skip_conditional_fields: false,
+    fallback_definition: {},
+    view: :default
   )
-    Generator.new(serializer, model, options).generate
+    Generator.new(serializer:, model:, skip_conditional_fields:, fallback_definition:, view:).generate
   end
 end

metadata

@@ -1,42 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blueprinter_schema
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.1
 platform: ruby
 authors:
 - thisismydesign
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  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: blueprinter
-  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'
+dependencies: []
 email:
 - git.thisismydesign@gmail.com
 executables: []