wcc-contentful-app 0.2.2

data/lib/generators/wcc/templates/menu/generated_add_menus.ts

@@ -0,0 +1,192 @@
+
+import Migration from 'contentful-migration-cli'
+
+export = function (migration: Migration) {
+  const menu = migration.createContentType('menu', {
+    displayField: 'name',
+    name: 'Menu',
+    description: 'A Menu contains a number of Menu Buttons or other Menus, ' +
+      'which will be rendered as drop-downs.'
+  })
+
+  menu.createField('name', {
+    name: 'Menu Name',
+    type: 'Symbol',
+    localized: false,
+    required: true,
+    validations: [],
+    disabled: false,
+    omitted: false
+  })
+
+  menu.createField('items', {
+    name: 'Items',
+    type: 'Array',
+    localized: false,
+    required: false,
+    validations: [],
+    disabled: false,
+    omitted: false,
+    items:
+      {
+        type: 'Link',
+        validations:
+          [{
+            linkContentType:
+              ['dropdownMenu',
+                'menuButton'],
+            message: 'The items must be either buttons or drop-down menus.'
+          }],
+        linkType: 'Entry'
+      }
+  })
+
+  menu.changeEditorInterface('name', 'singleLine')
+  menu.changeEditorInterface('items', 'entryLinksEditor')
+
+  const menubutton = migration.createContentType('menuButton', {
+    displayField: 'text',
+    name: 'Menu Button',
+    description: 'A Menu Button is a clickable button that goes on a Menu.  It has a link to a Page or a URL.'
+  })
+
+  menubutton.createField('text', {
+    name: 'Text',
+    type: 'Symbol',
+    localized: false,
+    required: true,
+    validations:
+      [{
+        size:
+          {
+            min: 1,
+            max: 60
+          },
+        message: 'A Menu Button should have a very short text field - ideally a single word.  Please limit the text to 60 characters.'
+      }],
+    disabled: false,
+    omitted: false
+  })
+
+  menubutton.createField('icon', {
+    name: 'Icon',
+    type: 'Link',
+    localized: false,
+    required: false,
+    validations: [{ linkMimetypeGroup: ['image'] }],
+    disabled: false,
+    omitted: false,
+    linkType: 'Asset'
+  })
+
+  menubutton.createField('externalLink', {
+    name: 'External Link',
+    type: 'Symbol',
+    localized: false,
+    required: false,
+    validations:
+      [{
+        regexp: { pattern: '^(\\w+):(\\/\\/)?(\\w+:{0,1}\\w*@)?((\\w+\\.)+[^\\s\\/#]+)(:[0-9]+)?(\\/|(\\/|\\#)([\\w#!:.?+=&%@!\\-\\/]+))?$|^(\\/|(\\/|\\#)([\\w#!:.?+=&%@!\\-\\/]+))$' },
+        message: 'The external link must be a URL like \'https://www.watermark.org/\', a mailto url like \'mailto:info@watermark.org\', or a relative URL like \'#location-on-page\''
+      }],
+    disabled: false,
+    omitted: false
+  })
+
+  menubutton.createField('link', {
+    name: 'Page Link',
+    type: 'Link',
+    localized: false,
+    required: false,
+    validations:
+      [{
+        linkContentType: ['page'],
+        message: 'The Page Link must be a link to a Page which has a slug.'
+      }],
+    disabled: false,
+    omitted: false,
+    linkType: 'Entry'
+  })
+
+  menubutton.createField('ionIcon', {
+    name: 'Ion Icon',
+    type: 'Symbol',
+    localized: false,
+    required: false,
+    validations:
+      [{
+        regexp: { pattern: '^ion-[a-z\\-]+$' },
+        message: 'The icon should start with \'ion-\', like \'ion-arrow-down-c\'.  See http://ionicons.com/'
+      }],
+    disabled: false,
+    omitted: false
+  })
+
+  menubutton.createField('style', {
+    name: 'Style',
+    type: 'Symbol',
+    localized: false,
+    required: false,
+    validations: [{ in: ['oval-border'] }],
+    disabled: false,
+    omitted: false
+  })
+
+  menubutton.changeEditorInterface('text', 'singleLine')
+  menubutton.changeEditorInterface('icon', 'assetLinkEditor')
+  menubutton.changeEditorInterface('externalLink', 'singleLine')
+  menubutton.changeEditorInterface('link', 'entryLinkEditor')
+  menubutton.changeEditorInterface('ionIcon', 'singleLine')
+  menubutton.changeEditorInterface('style', 'dropdown')
+
+  const dropdownmenu = migration.createContentType('dropdownMenu', {
+    displayField: 'name',
+    name: 'Dropdown Menu',
+    description: 'A Dropdown Menu can be attached to a main menu to show additional menu items on click.'
+  })
+
+  dropdownmenu.createField('name', {
+    name: 'Menu Name',
+    type: 'Symbol',
+    localized: false,
+    required: false,
+    validations: [],
+    disabled: false,
+    omitted: false
+  })
+
+  dropdownmenu.createField('label', {
+    name: 'Menu Label',
+    type: 'Link',
+    localized: false,
+    required: false,
+    validations: [{ linkContentType: ['menuButton'] }],
+    disabled: false,
+    omitted: false,
+    linkType: 'Entry'
+  })
+
+  dropdownmenu.createField('items', {
+    name: 'Items',
+    type: 'Array',
+    localized: false,
+    required: false,
+    validations: [],
+    disabled: false,
+    omitted: false,
+    items:
+      {
+        type: 'Link',
+        validations:
+          [{
+            linkContentType:
+              ['menuButton']
+          }],
+        linkType: 'Entry'
+      }
+  })
+
+  dropdownmenu.changeEditorInterface('name', 'singleLine')
+  dropdownmenu.changeEditorInterface('label', 'entryLinkEditor')
+  dropdownmenu.changeEditorInterface('items', 'entryLinksEditor')
+}

data/lib/generators/wcc/templates/menu/models/menu.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This model represents the 'menu' content type in Contentful.  Any linked
+# entries of the 'menu' content type will be resolved as instances of this class.
+# It exposes #find, #find_by, and #find_all methods to query Contentful.
+class Menu < WCC::Contentful::Model::Menu
+  # Add custom validations to ensure that app-specific properties exist:
+  # validate_field :foo, :String, :required
+  # validate_field :bar_links, :Array, link_to: %w[bar baz]
+
+  # Override functionality or add utilities
+  #
+  # # Example: override equality
+  # def ===(other)
+  #   ...
+  # end
+  #
+  # # Example: override "name" attribute to always be camelized.
+  # #          `@name` is populated by the gem in the initializer.
+  # def name
+  #   @name_camelized ||= @name.camelize(true)
+  # end
+end

data/lib/generators/wcc/templates/menu/models/menu_button.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This model represents the 'menuButton' content type in Contentful.  Any linked
+# entries of the 'menuButton' content type will be resolved as instances of this class.
+# It exposes #find, #find_by, and #find_all methods to query Contentful.
+class MenuButton < WCC::Contentful::Model::MenuButton
+  # Add custom validations to ensure that app-specific properties exist:
+  # validate_field :foo, :String, :required
+  # validate_field :bar_links, :Array, link_to: %w[bar baz]
+
+  # Override functionality or add utilities
+  #
+  # # Example: override equality
+  # def ===(other)
+  #   ...
+  # end
+  #
+  # # Example: override "text" attribute to always be camelized.
+  # #          `@text` is populated by the gem in the initializer.
+  # def text
+  #   @text_camelized ||= @text.camelize(true)
+  # end
+end

data/lib/generators/wcc/templates/page/generated_add_pages.ts

@@ -0,0 +1,50 @@
+import Migration from 'contentful-migration-cli'
+
+export = function (migration: Migration) {
+  const page = migration.createContentType('page')
+    .name('Page')
+    .description('A page describes a collection of sections that correspond' +
+     'to a URL slug')
+    .displayField('title')
+
+  page.createField('title')
+    .name('Title')
+    .type('Symbol')
+    .required(true)
+
+  page.createField('slug')
+    .name('Slug')
+    .type('Symbol')
+    .required(true)
+    .validations([
+      {
+        unique: true
+      },
+      {
+        regexp: { pattern: "(\\/|\\/([\w#!:.?+=&%@!\\-\\/]))?$" },
+        message: "The slug must look like the path part of a URL and begin with a forward slash, example: '/my-page-slug'"
+      }
+    ])
+
+  page.createField('sections')
+    .name('Sections')
+    .type('Array')
+    .items({
+      type: 'Link',
+      linkType: 'Entry'
+    })
+
+  page.createField('subpages')
+    .name('Subpages')
+    .type('Array')
+    .items({
+      type: 'Link',
+      linkType: 'Entry',
+      validations: [
+        {
+          linkContentType: [ 'page' ]
+        }
+      ]
+    })
+
+}

data/lib/generators/wcc/templates/page/models/page.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This model represents the 'page' content type in Contentful.  Any linked
+# entries of the 'page' content type will be resolved as instances of this class.
+# It exposes #find, #find_by, and #find_all methods to query Contentful.
+class Page < WCC::Contentful::Model::Page
+  # Add custom validations to ensure that app-specific properties exist:
+  # validate_field :foo, :String, :required
+  # validate_field :bar_links, :Array, link_to: %w[bar baz]
+
+  # Override functionality or add utilities
+  #
+  # # Example: override equality
+  # def ===(other)
+  #   ...
+  # end
+  #
+  # # Example: override "title" attribute to always be titlecase.
+  # #          `@title` is populated by the gem in the initializer.
+  # def title
+  #   @title_titlecased ||= @title.titlecase
+  # end
+end

data/lib/generators/wcc/templates/release

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+set -e
+
+echo "Migrating database..."
+bundle exec rake db:migrate
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+$DIR/contentful migrate -y

data/lib/generators/wcc/templates/wcc_contentful.rb

@@ -0,0 +1,17 @@
+
+WCC::Contentful.configure do |config|
+  # Required
+  config.access_token = # Contentful CDN access token
+  config.space = # Contentful Space ID
+
+  # Optional
+  config.management_token = # Contentful API management token
+  config.default_locale = # Set default locale, if left blank this is 'en-US'
+  config.content_delivery = # :direct, :eager_sync, or :lazy_sync
+end
+
+# Download content types, build models, and sync content
+WCC::Contentful.init!
+
+# Validate that models conform to a defined specification
+WCC::Contentful.validate_models! unless defined?(Rails) && Rails.env.development?

data/lib/tasks/validate.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+namespace :wcc_contentful do
+  desc 'Validates content types in your space against the validations defined on your models'
+  task :validate, :environment do |_t|
+    # Ensure application models are loaded before we validate
+    Rails.application.eager_load!
+
+    client = Services.instance.management_client ||
+      Services.instance.client
+
+    content_types = client.content_types(limit: 1000).items
+
+    content_types = WCC::Contentful::ModelValidators
+      .transform_content_types_for_validation(content_types)
+
+    errors = WCC::Contentful::Model.schema.call(content_types)
+    raise WCC::Contentful::ValidationError, errors.errors unless errors.success?
+  end
+end

data/lib/wcc/contentful/app.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative './app/exceptions'
+require_relative './app/model_validators'
+require_relative './ext/model'
+
+module WCC::Contentful::App
+  def self.init!
+    raise ArgumentError, 'Please first call WCC::Contentful.init!' unless WCC::Contentful.types
+
+    # Extend all model types w/ validation & extra fields
+    WCC::Contentful.types.each_value do |t|
+      file = File.dirname(__FILE__) + "/model/#{t.name.underscore}.rb"
+      require file if File.exist?(file)
+    end
+  end
+end

data/lib/wcc/contentful/app/exceptions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::App
+  # Raised by {WCC::Contentful.validate_models!} if a content type in the space
+  # does not match the validation defined on the associated model.
+  class ValidationError < StandardError
+    Message =
+      Struct.new(:path, :error) do
+        def to_s
+          "#{path}: #{error}"
+        end
+      end
+
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = ValidationError.join_msg_keys(errors)
+      super("Content Type Schema from Contentful failed validation!\n  #{@errors.join("\n  ")}")
+    end
+
+    # Turns the error messages hash into an array of message structs like:
+    # menu.fields.name.type: must be equal to String
+    def self.join_msg_keys(hash)
+      ret =
+        hash.map do |k, v|
+          if v.is_a?(Hash)
+            msgs = join_msg_keys(v)
+            msgs.map { |msg| Message.new(k.to_s + '.' + msg.path, msg.error) }
+          else
+            v.map { |msg| Message.new(k.to_s, msg) }
+          end
+        end
+      ret.flatten(1)
+    end
+  end
+end

data/lib/wcc/contentful/app/model_validators.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'dry-validation'
+
+require_relative 'model_validators/dsl'
+
+module WCC::Contentful::App::ModelValidators
+  def schema
+    return if validations.nil? || validations.empty?
+
+    all_field_validations =
+      validations.each_with_object({}) do |(content_type, procs), h|
+        next if procs.empty?
+
+        # "page": {
+        #   "sys": { ... }
+        #   "fields": {
+        #     "title": { ... },
+        #     "sections": { ... },
+        #     ...
+        #   }
+        # }
+        h[content_type] =
+          Dry::Validation.Schema do
+            # Had to dig through the internals of Dry::Validation to find
+            # this magic incantation
+            procs.each { |dsl| instance_eval(&dsl.to_proc) }
+          end
+      end
+
+    Dry::Validation.Schema do
+      all_field_validations.each do |content_type, fields_schema|
+        required(content_type).schema do
+          required('fields').schema(fields_schema)
+        end
+      end
+    end
+  end
+
+  def validations
+    # This needs to be a class variable so that subclasses defined in application
+    # code can add to the total package of model validations
+    # rubocop:disable Style/ClassVars
+    @@validations ||= {}
+    # rubocop:enable Style/ClassVars
+  end
+
+  # Accepts a block which uses the {dry-validation DSL}[http://dry-rb.org/gems/dry-validation/]
+  # to validate the 'fields' object of a content type.
+  def validate_fields(&block)
+    raise ArgumentError, 'validate_fields requires a block' unless block_given?
+
+    dsl = ProcDsl.new(Proc.new(&block))
+
+    ct = try(:content_type) || name.demodulize.camelize(:lower)
+    (validations[ct] ||= []) << dsl
+  end
+
+  # Validates a single field is of the expected type.
+  # Type expectations are one of:
+  #
+  # [:String]   the field type must be `Symbol` or `Text`
+  # [:Int]      the field type must be `Integer`
+  # [:Float]    the field type must be `Number`
+  # [:DateTime] the field type must be 'Date'
+  # [:Asset]    the field must be a link and the `linkType` must be `Asset`
+  # [:Link]     the field must be a link and the `linkType` must be `Entry`.
+  # [:Location] the field type must be `Location`
+  # [:Boolean]  the field type must be `Boolean`
+  # [:Json]     the field type must be `Json` - a json blob.
+  # [:Array]    the field must be a List.
+  #
+  # Additional validation options can be enforced:
+  #
+  # [:required] the 'Required Field' checkbox must be checked
+  # [:optional] the 'Required Field' checkbox must not be checked
+  # [:link_to]  (only `:Link` or `:Array` type) the given content type(s) must be
+  #             checked in the 'Accept only specified entry type' validations
+  #             Example:
+  #               validate_field :button, :Link, link_to: ['button', 'altButton']
+  #
+  # [:items]    (only `:Array` type) the items of the list must be of the given type.
+  #             Example:
+  #               validate_field :my_strings, :Array, items: :String
+  #
+  # Examples:
+  # see WCC::Contentful::Model::Menu and WCC::Contentful::Model::MenuButton
+  def validate_field(field, type, *options)
+    dsl = FieldDsl.new(field, type, options)
+
+    ct = try(:content_type) || name.demodulize.camelize(:lower)
+    (validations[ct] ||= []) << dsl
+  end
+
+  def no_validate_field(field)
+    ct = try(:content_type) || name.demodulize.camelize(:lower)
+    return unless v = validations[ct]
+
+    field = field.to_s.camelize(:lower) unless field.is_a?(String)
+    v.reject! { |dsl| dsl.try(:field) == field }
+  end
+
+  # Accepts a content types response from the API and transforms it
+  # to be acceptible for the validator.
+  def self.transform_content_types_for_validation(content_types)
+    if !content_types.is_a?(Array) && items = content_types.try(:[], 'items')
+      content_types = items
+    end
+
+    # Transform the array into a hash keyed by content type ID
+    content_types.each_with_object({}) do |ct, ct_hash|
+      # Transform the fields into a hash keyed by field ID
+      ct['fields'] =
+        ct['fields'].each_with_object({}) do |f, f_hash|
+          f_hash[f['id']] = f
+        end
+
+      ct_hash[ct.dig('sys', 'id')] = ct
+    end
+  end
+end