contentful-database-importer 0.1.0

data/lib/contentful/database_importer/resource.rb

@@ -0,0 +1,88 @@
+require 'contentful/database_importer/support'
+require 'contentful/database_importer/resource_class_methods'
+require 'contentful/database_importer/resource_coercions'
+require 'contentful/database_importer/resource_relationships'
+require 'contentful/database_importer/resource_bootstrap_methods'
+require 'contentful/database_importer/resource_bootstrap_class_methods'
+require 'mimemagic'
+
+module Contentful
+  module DatabaseImporter
+    # Resource for mapping Database Tables to
+    # Contentful Content Types and Entries
+    module Resource
+      include ResourceCoercions
+      include ResourceRelationships
+      include ResourceBootstrapMethods
+
+      def self.included(base)
+        base.extend(ResourceClassMethods)
+        base.extend(ResourceBootstrapClassMethods)
+      end
+
+      attr_reader :bootstrap_fields,
+                  :excluded_fields,
+                  :index,
+                  :associated_assets
+
+      def initialize(row, index = 0)
+        @index = index
+        @bootstrap_fields = {}
+        @excluded_fields = {}
+        @raw = row
+        @associated_assets = []
+
+        row.each do |db_name, value|
+          process_row_field(db_name, value)
+        end
+
+        process_relationships
+      end
+
+      def process_row_field(db_name, value)
+        field_definition = self.class.fields.find { |f| f[:db_name] == db_name }
+
+        return unless field_definition
+
+        value = pre_process(field_definition, value)
+        value = coerce(field_definition, value)
+
+        if field_definition[:exclude_from_output]
+          @excluded_fields[field_definition[:maps_to]] = value
+        else
+          @bootstrap_fields[field_definition[:maps_to]] = value
+        end
+      end
+
+      def process_relationships
+        self.class.relationship_fields.each do |relationship_field_definition|
+          relations = fetch_relations(relationship_field_definition)
+          @bootstrap_fields[relationship_field_definition[:maps_to]] = relations
+        end
+      end
+
+      def pre_process(field_definition, value)
+        return value unless field_definition[:pre_process]
+
+        transformation = field_definition[:pre_process]
+
+        return send(transformation, value) if transformation.is_a? ::Symbol
+        return transformation.call(value) if transformation.respond_to?(:call)
+
+        raise
+      rescue
+        error = 'Pre Process could not be done for '
+        error += "#{field_definition[:maps_to]} - #{transformation}"
+        raise error
+      end
+
+      def id
+        self.class.id_generator = IdGenerator::Base.new(
+          self.class.default_generator_options
+        ) if self.class.id_generator.nil?
+
+        self.class.id_generator.run(self, index)
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/resource_bootstrap_class_methods.rb

@@ -0,0 +1,113 @@
+module Contentful
+  module DatabaseImporter
+    # Bootstrap related Class Methods
+    module ResourceBootstrapClassMethods
+      TYPE_MAPPINGS = {
+        symbol: 'Symbol',
+        text: 'Text',
+        date: 'Date',
+        object: 'Object',
+        location: 'Location',
+        link: 'Link',
+        integer: 'Integer',
+        number: 'Number',
+        boolean: 'Boolean'
+      }.freeze
+
+      def definition_type(type)
+        if type == :string
+          type = :symbol
+        elsif link?(type)
+          type = :link
+        end
+
+        TYPE_MAPPINGS[type]
+      end
+
+      def link_type(type)
+        return 'Asset' if type == :asset
+        return 'Entry' if resource?(type)
+
+        raise 'Type class is not a valid Link'
+      end
+
+      def items_type(field_data)
+        return {
+          type: 'Link',
+          linkType: array_link_type(field_data)
+        } if array_link?(field_data)
+
+        type = definition_type(field_data[:item_type])
+
+        error = 'Array item type could not be mapped for '
+        error += field_data[:maps_to].to_s
+        raise error if type.nil?
+
+        type
+      end
+
+      def array_link?(field_data)
+        (field_data[:type] == :array && field_data[:item_type] == :asset) ||
+          (resource?(field_data[:type]) &&
+           [:many, :through].include?(field_data[:relationship]))
+      end
+
+      def array_link_type(field_data)
+        return 'Asset' if field_data[:item_type] == :asset
+        return 'Entry' if resource?(field_data[:type])
+      end
+
+      def link?(type)
+        type == :asset || resource?(type)
+      end
+
+      def array?(field_data)
+        field_data[:type] == :array ||
+          (resource?(field_data[:type]) &&
+           [:many, :through].include?(field_data[:relationship]))
+      end
+
+      def resource?(other)
+        return false unless other.respond_to?(:ancestors)
+        other.ancestors.include?(::Contentful::DatabaseImporter::Resource)
+      end
+
+      def link_type?(field_data)
+        link?(field_data[:type]) && !array_link?(field_data)
+      end
+
+      def basic_field_definition(field_data)
+        {
+          id: field_data[:maps_to],
+          name: field_data[:name],
+          type: definition_type(field_data[:type])
+        }
+      end
+
+      def field_definition(field_data)
+        definition = basic_field_definition(field_data)
+
+        definition[:type] = 'Array' if array?(field_data)
+        definition[:linkType] = link_type(
+          field_data[:type]
+        ) if link_type?(field_data)
+        definition[:items] = items_type(field_data) if array?(field_data)
+
+        definition
+      end
+
+      def fields_definition
+        fields.map { |f| field_definition(f) }
+      end
+
+      def content_type_definition
+        {
+          id: content_type_id,
+          name: content_type_name,
+          displayField: display_field,
+          fields: fields_definition
+        }
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/resource_bootstrap_methods.rb

@@ -0,0 +1,22 @@
+module Contentful
+  module DatabaseImporter
+    # Bootstrap related methods
+    module ResourceBootstrapMethods
+      def to_bootstrap
+        {
+          sys: {
+            id: id
+          },
+          fields: bootstrap_fields
+        }
+      end
+
+      def to_link
+        {
+          linkType: 'Entry',
+          id: id
+        }
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/resource_class_methods.rb

@@ -0,0 +1,126 @@
+
+module Contentful
+  module DatabaseImporter
+    # Class Methods for Resource
+    module ResourceClassMethods
+      attr_accessor :id_generator
+
+      def table_name
+        (@table_name || Support.snake_case(name)).to_sym
+      end
+
+      def table_name=(name)
+        @table_name = name
+      end
+
+      def content_type_id
+        @content_type_id || Support.snake_case(name)
+      end
+
+      def content_type_id=(ct_id)
+        @content_type_id = ct_id
+      end
+
+      def content_type_name
+        (@content_type_name || name)
+      end
+
+      def content_type_name=(name)
+        @content_type_name = name
+      end
+
+      def default_generator_options
+        {
+          table_name: table_name,
+          content_type_id: content_type_id,
+          class_name: name,
+          template: '{{content_type_id}}_{{index}}'
+        }
+      end
+
+      def id(id_generator_class, options = {})
+        @id_generator = id_generator_class.new(
+          default_generator_options.merge(options)
+        )
+      end
+
+      def display_field
+        @display_field || (fields.find do |f|
+          f[:type] == :string || f[:type] == :symbol
+        end || {})[:maps_to]
+      end
+
+      def display_field=(field_name)
+        @display_field = field_name
+      end
+
+      def fields
+        @fields || []
+      end
+
+      def relationship_fields
+        @fields.select { |f| resource?(f[:type]) }
+      end
+
+      def prepare_standard_field_options(database_name, options)
+        {
+          db_name: database_name,
+          maps_to: options.fetch(:maps_to, database_name),
+          name: options.fetch(:name, database_name),
+          type: options.fetch(:type),
+          pre_process: options.fetch(:pre_process, nil),
+          exclude_from_output: options.fetch(:exclude_from_output, false)
+        }
+      end
+
+      def prepare_field(database_name, options)
+        field = prepare_standard_field_options(database_name, options)
+        field[:item_type] = options.fetch(:item_type) if field[:type] == :array
+        fetch_relationship_options(
+          field,
+          options
+        ) if options.fetch(:relationship, false)
+
+        field
+      end
+
+      def field(database_name, options = {})
+        @fields ||= []
+        @fields << prepare_field(database_name, options)
+      end
+
+      def fetch_many_relationship_options(field, options)
+        field[:id_field] = options.fetch(:id_field)
+        field[:key] = options.fetch(:key)
+      end
+      alias fetch_one_relationship_options fetch_many_relationship_options
+
+      def fetch_through_relationship_options(field, options)
+        field[:through] = options.fetch(:through)
+        field[:primary_id_field] = options.fetch(:primary_id_field)
+        field[:foreign_id_field] = options.fetch(:foreign_id_field)
+        field[:primary_key] = options.fetch(:primary_key)
+        field[:foreign_key] = options.fetch(:foreign_key)
+      end
+
+      def fetch_relationship_options(field, options)
+        field[:relationship] = options.fetch(:relationship)
+
+        send(
+          "fetch_#{options.fetch(:relationship)}_relationship_options",
+          field,
+          options
+        )
+      end
+
+      def all
+        entries = []
+        rows = Contentful::DatabaseImporter.database[table_name].all
+        rows.each_with_index do |row, index|
+          entries << new(row, index)
+        end
+        entries
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/resource_coercions.rb

@@ -0,0 +1,113 @@
+module Contentful
+  module DatabaseImporter
+    # Coercion methods for Resource
+    module ResourceCoercions
+      def coerce(field_definition, value)
+        return if value.nil?
+
+        type = field_definition[:type]
+
+        return coerce_array(field_definition, value) if type == :array
+
+        send("coerce_#{type}".to_sym, value)
+      end
+
+      def coerce_symbol(value)
+        value.to_s
+      end
+      alias coerce_string coerce_symbol
+      alias coerce_text coerce_symbol
+
+      def coerce_number(value)
+        value.to_f
+      end
+
+      def coerce_integer(value)
+        value.to_i
+      end
+
+      def coerce_array(field_definition, value)
+        item_type = field_definition[:item_type]
+
+        raise "Can't coerce nested arrays" if item_type == :array
+
+        value = value.split(',').map(&:strip) if value.is_a?(::String)
+        value.map { |v| coerce({ type: item_type }, v) }
+      end
+
+      def coerce_hash_location(value)
+        {
+          lat: value.fetch(:lat, nil) || value.fetch(:latitude, nil),
+          lon: value.fetch(:lon, nil) || value.fetch(:longitude, nil)
+        }
+      end
+
+      def coerce_array_location(value)
+        {
+          lat: value[0],
+          lon: value[1]
+        }
+      end
+
+      def coerce_location(value)
+        return coerce_hash_location(value) if value.is_a?(::Hash)
+
+        return coerce_array_location(value) if value.is_a?(::Array)
+
+        if value.is_a?(::String) && value.include?(',')
+          parts = value.split(',').map(&:strip).map(&:to_f)
+          return coerce_array_location(parts)
+        end
+
+        raise "Can't coerce #{value} to Location"
+      end
+
+      def coerce_boolean(value)
+        # rubocop:disable Style/DoubleNegation
+        !!value
+        # rubocop:enable Style/DoubleNegation
+      end
+
+      def coerce_date(value)
+        case value
+        when Date, DateTime
+          value.iso8601
+        when String
+          value
+        else
+          raise "Can't coerce #{value} to ISO8601 Date"
+        end
+      end
+
+      def coerce_object(*)
+        raise 'Not yet supported by Contentful Bootstrap'
+      end
+
+      def create_associated_asset(name, value)
+        extension = value.split('.').last
+        associated_assets << {
+          id: Support.snake_case(name),
+          title: name,
+          file: {
+            filename: name,
+            url: value,
+            contentType: MimeMagic.by_extension(extension).type
+          }
+        }
+      end
+
+      def coerce_asset(value)
+        raise 'Only URL Strings supported for Assets' unless value.is_a?(String)
+
+        name = value.split('/').last.split('.').first
+
+        create_associated_asset(name, value)
+
+        {
+          linkType: 'Asset',
+          id: Support.snake_case(name)
+        }
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/resource_relationships.rb

@@ -0,0 +1,69 @@
+module Contentful
+  module DatabaseImporter
+    # Relationship methods for Resource
+    module ResourceRelationships
+      def fetch_relations(relationship_field_definition)
+        relations = [:many, :one, :through]
+        return send(
+          "fetch_#{relationship_field_definition[:relationship]}".to_sym,
+          relationship_field_definition
+        ) if relations.include?(relationship_field_definition[:relationship])
+
+        raise 'Invalid Relationship type'
+      end
+
+      def fetch_many(relationship_field_definition)
+        table_name = relationship_field_definition[:type].table_name
+        Contentful::DatabaseImporter.database[table_name].where(
+          relationship_field_definition[:key] =>
+            @raw[relationship_field_definition[:id_field]]
+        ).map do |row|
+          relationship_field_definition[:type].new(row).to_link
+        end
+      end
+
+      def fetch_one(relationship_field_definition)
+        table_name = relationship_field_definition[:type].table_name
+        row = Contentful::DatabaseImporter.database[table_name].where(
+          relationship_field_definition[:id_field] =>
+            @raw[relationship_field_definition[:key]]
+        ).first
+
+        return if row.nil?
+
+        relationship_field_definition[:type].new(row).to_link
+      end
+
+      def fetch_through_table_rows(relationship_field_definition)
+        through_table_name = relationship_field_definition[:through]
+
+        Contentful::DatabaseImporter.database[through_table_name].where(
+          relationship_field_definition[:primary_key] =>
+            @raw[relationship_field_definition[:primary_id_field]]
+        ).to_a
+      end
+
+      def resolve_through_relationship(through_row, field_definition)
+        table_name = field_definition[:type].table_name
+
+        related = Contentful::DatabaseImporter.database[table_name].where(
+          field_definition[:foreign_id_field] =>
+            through_row[field_definition[:foreign_key]]
+        ).first
+
+        field_definition[:type].new(related).to_link
+      end
+
+      def fetch_through(relationship_field_definition)
+        through = fetch_through_table_rows(relationship_field_definition)
+
+        through.map do |through_row|
+          resolve_through_relationship(
+            through_row,
+            relationship_field_definition
+          )
+        end
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/support.rb

@@ -0,0 +1,14 @@
+module Contentful
+  module DatabaseImporter
+    # Helpers
+    module Support
+      def self.snake_case(string)
+        string.gsub(/::/, '/')
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .tr('-', '_')
+              .downcase
+      end
+    end
+  end
+end

data/lib/contentful/database_importer/version.rb

@@ -0,0 +1,5 @@
+module Contentful
+  module DatabaseImporter
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/contentful/database_importer.rb

@@ -0,0 +1,59 @@
+require 'contentful/database_importer/version'
+require 'contentful/database_importer/config'
+require 'contentful/database_importer/resource'
+require 'contentful/database_importer/id_generator'
+require 'contentful/database_importer/json_generator'
+require 'contentful/bootstrap'
+require 'tempfile'
+require 'sequel'
+require 'json'
+
+# Top level space
+module Contentful
+  # Database Importer Tool
+  module DatabaseImporter
+    def self.config
+      @config ||= Config.new
+    end
+
+    def self.setup
+      yield config if block_given?
+
+      raise 'Configuration is incomplete' unless config.complete?
+    end
+
+    def self.database
+      error = 'Database Configuration not found'
+      raise error if config.database_connection.nil?
+
+      @database ||= ::Sequel.connect(config.database_connection)
+    end
+
+    def self.generate_json
+      JsonGenerator.generate_json
+    end
+
+    def self.generate_json!
+      JsonGenerator.generate_json!
+    end
+
+    def self.run_bootstrap!(file, json)
+      file.write(json)
+      file.close
+
+      Contentful::Bootstrap::CommandRunner.new.create_space(
+        config.space_name,
+        json_template: file.path
+      )
+    ensure
+      file.unlink
+    end
+
+    def self.run!
+      json = generate_json!
+
+      file = Tempfile.new("import_#{config.space_name}")
+      run_bootstrap!(file, json)
+    end
+  end
+end