kanji-web 0.1.0

data/lib/kanji/graph.rb

@@ -0,0 +1 @@
+require "kanji/graph/container"

data/lib/kanji/graph/coerce_type.rb

@@ -0,0 +1,66 @@
+require "graphql"
+
+module Kanji
+  class Graph
+    class CoerceType
+      def self.call(type)
+        if array_type?(type)
+          member_type = get_member_type(type)
+          graphql_type = get_graphql_type(member_type)
+          graphql_type.to_list_type
+        else
+          get_graphql_type(type)
+        end
+      end
+
+      private
+
+      TYPE_MAP = {
+        "String" => "String",
+        "Integer" => "Int",
+        "Float" => "Float",
+        "FalseClass" => "Boolean",
+        "TrueClass | FalseClass" => "Boolean",
+        "FalseClass | TrueClass" => "Boolean"
+      }
+
+      def self.get_graphql_type(type)
+        return type if type.is_a?(GraphQL::ObjectType)
+
+        type_string = TYPE_MAP[get_primitive_type(type)]
+
+        if type.optional?
+          GraphQL::Define::TypeDefiner.instance.send(type_string)
+        else
+          !GraphQL::Define::TypeDefiner.instance.send(type_string)
+        end
+      end
+
+      def self.get_primitive_type(type)
+        type.optional? ?
+          type.right.primitive.to_s :
+          type.primitive.to_s
+      end
+
+      def self.get_member_type(type)
+        member_type = type.options[:member] || type.type.options[:member]
+
+        if has_ancestor?(member_type, Kanji::Type)
+          member_type[:graphql_type]
+        else
+          member_type
+        end
+      end
+
+      def self.array_type?(type)
+        return type.primitive == Array if defined?(type.primitive)
+        defined?(type.type) && type.type.primitive == Array
+      end
+
+      def self.has_ancestor?(type, ancestor)
+        return false unless type.respond_to?(:ancestors)
+        type.ancestors.include?(ancestor)
+      end
+    end
+  end
+end

data/lib/kanji/graph/container.rb

@@ -0,0 +1,18 @@
+require "dry-container"
+require "kanji/graph/register_object"
+require "kanji/graph/register_mutation"
+require "kanji/graph/query"
+require "kanji/graph/schema"
+
+module Kanji
+  class Graph
+    class Container
+      extend Dry::Container::Mixin
+
+      register :register_object, -> (params) { RegisterObject.new(params) }
+      register :register_mutation, -> (params) { RegisterMutation.new(params) }
+      register :query, Kanji::Graph::Query
+      register :schema, Kanji::Graph::Schema
+    end
+  end
+end

data/lib/kanji/graph/helpers.rb

@@ -0,0 +1,27 @@
+require "dry-container"
+require "dry-auto_inject"
+require "kanji/graph/coerce_type"
+require "graphql"
+
+module Graph
+  class Helpers
+    extend Dry::Container::Mixin
+
+    Import = Dry::AutoInject(Graph::Helpers)
+
+    register :coerce_type, -> { Graph::CoerceType.new }
+
+    register :explain do
+      ->(schema) { schema.execute GraphQL::Introspection::INTROSPECTION_QUERY }
+    end
+
+    register :generate do
+      lambda do |schema, destination|
+        result = JSON.pretty_generate(explain(schema))
+        unless File.exist?(destination) && File.read(destination) == result
+          File.write(destination, result)
+        end
+      end
+    end
+  end
+end

data/lib/kanji/graph/import.rb

@@ -0,0 +1,8 @@
+require "dry-auto_inject"
+require "kanji/graph/container"
+
+module Kanji
+  class Graph
+    Import = Dry::AutoInject(Graph::Container)
+  end
+end

data/lib/kanji/graph/query.rb

@@ -0,0 +1,16 @@
+require "graphql"
+
+module Kanji
+  class Graph
+    class Query
+      def self.call(schema:, query:, variables: {}, context: {})
+        GraphQL::Query.new(
+          schema.call,
+          query,
+          variables: variables,
+          context: context
+        ).result
+      end
+    end
+  end
+end

data/lib/kanji/graph/register_mutation.rb

@@ -0,0 +1,43 @@
+require "graphql"
+require "dry-initializer"
+require "kanji/types"
+require "kanji/graph/coerce_type"
+
+module Kanji
+  class Graph
+    class RegisterMutation
+      extend Dry::Initializer
+
+      option :return_type, Types::Class
+      option :attributes, Types::Strict::Array.member(Type::Attribute)
+      option :name, Types::Strict::String
+      option :description, Types::Strict::String, optional: true
+      option :resolve, Types::Callable
+
+      def call
+        return_type = self.return_type
+        attributes = self.attributes
+        name = self.name
+        description = self.description
+        resolve_proc = self.resolve
+        coercer = Graph::CoerceType
+
+        GraphQL::Field.define do
+          type -> { return_type }
+          name name
+          description description
+
+          attributes.each do |attribute|
+            argument(
+              attribute.name,
+              coercer.(attribute.type),
+              attribute.description
+            )
+          end
+
+          resolve resolve_proc
+        end
+      end
+    end
+  end
+end

data/lib/kanji/graph/register_object.rb

@@ -0,0 +1,40 @@
+require "graphql"
+require "dry-initializer"
+require "kanji/types"
+require "kanji/type/attribute"
+require "kanji/graph/coerce_type"
+
+module Kanji
+  class Graph
+    class RegisterObject
+      extend Dry::Initializer
+
+      option :attributes, Types::Strict::Array.member(Type::Attribute)
+      option :name, Types::Strict::String
+      option :description, Types::Strict::String, optional: true
+
+      def call
+        name = "#{self.name}Type"
+        attributes = self.attributes
+        description = self.description
+        coercer = Graph::CoerceType
+
+        GraphQL::ObjectType.define do
+          name name
+          description description
+
+          attributes.each do |attribute|
+            field attribute.name do
+              type -> { coercer.(attribute.type) }
+              description attribute.description
+
+              if attribute.resolve
+                resolve attribute.resolve
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanji/graph/schema.rb

@@ -0,0 +1,17 @@
+require "graphql"
+
+module Kanji
+  class Graph
+    class Schema
+      def call(query_type, mutation_type)
+        GraphQL::Schema.define do
+          query -> { query_type }
+          mutation -> { mutation_type }
+
+          max_depth 10
+          max_complexity 200
+        end
+      end
+    end
+  end
+end

data/lib/kanji/import.rb

@@ -0,0 +1,5 @@
+require "kanji/container"
+
+module Kanji
+  Import = Kanji::Container.injector
+end

data/lib/kanji/instance_define.rb

@@ -0,0 +1,11 @@
+module Kanji
+  module InstanceDefine
+    def instance_define(*args)
+      args.each do |arg|
+        define_method "#{arg}" do |value|
+          instance_variable_set("@_#{arg}", value)
+        end
+      end
+    end
+  end
+end

data/lib/kanji/logger.rb

@@ -0,0 +1,10 @@
+require "kanji/container"
+
+Kanji::Container.finalize :logger do |container|
+  require "logger"
+
+  container.register(
+    :logger,
+    Logger.new(container.root.join("log/#{container.config.env}.log"))
+  )
+end

data/lib/kanji/repository.rb

@@ -0,0 +1,53 @@
+require "rom-repository"
+require "dry/core/inflector"
+
+module Kanji
+  class Repository < ROM::Repository::Root
+    def klass
+      @_klass ||= self.class
+    end
+
+    def relation_name
+      @_relation_name ||= begin
+        name = Dry::Core::Inflector.demodulize(klass.name)
+        Dry::Core::Inflector.underscore(name)
+      end
+    end
+
+    def type
+      @_type ||= begin
+        name = Dry::Core::Inflector.demodulize(klass.name)
+        singular_name = Dry::Core::Inflector.singularize(name)
+        Dry::Core::Inflector.constantize("Types::#{singular_name}")
+      end
+    end
+
+    def relation
+      @_relation ||= relations[relation_name].map_to(type)
+    end
+
+    def value_object
+      @_value_object ||= type.resolve(:value_object)
+    end
+
+    def all
+      relation.to_a
+    end
+
+    def create(params)
+      pk = relation.insert(params)
+      relation.where(id: pk).one
+    end
+
+    def update(params)
+      relation.where(id: params["id"]).update(params)
+      relation.where(id: params["id"]).one
+    end
+
+    def destroy(id)
+      item = relation.where(id: id).one
+      relation.where(id: id).delete
+      item
+    end
+  end
+end

data/lib/kanji/templates/.gitignore

@@ -0,0 +1,11 @@
+# Ignore app settings (copy to .example.env.* to check in example files)
+/.env*
+
+# RSpec
+/spec/examples.txt
+
+# Logs
+/log/*.log
+
+# Temp files
+tmp/*

data/lib/kanji/templates/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/kanji/templates/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem "kanji", path: "~/code/kanji"
+gem "pg"
+
+group :development, :test do
+  gem "pry-byebug", platform: :mri
+end
+
+group :test do
+  gem "database_cleaner"
+  gem "rspec"
+  gem "rom-factory"
+end

data/lib/kanji/templates/README.md.tt

@@ -0,0 +1,12 @@
+# <%= config[:camel_cased_app_name] %>
+
+Welcome! You’ve generated an app using Kanji.
+
+## First steps
+
+1. Run `bundle`
+1. Review `.env` & `.env.test` (and make a copy to e.g. `.example.env` if you want example settings checked in)
+1. Create a `blog_development` database
+1. Add your own steps to `bin/setup`
+1. Run the app with `bundle exec shotgun -p 3000 -o 0.0.0.0 config.ru`
+1. Initialize git with `git init` and make your initial commit

data/lib/kanji/templates/Rakefile.tt

@@ -0,0 +1,113 @@
+require "bundler/setup"
+require "pry-byebug" unless ENV["RACK_ENV"] == "production"
+require "rom/sql/rake_task"
+require "shellwords"
+require_relative "system/<%= config[:underscored_project_name] %>/container"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new :spec
+  task default: [:spec]
+rescue LoadError
+end
+
+def db
+  <%= config[:camel_cased_app_name] %>::Container["persistence.db"]
+end
+
+def settings
+  <%= config[:camel_cased_app_name] %>::Container["settings"]
+end
+
+def database_uri
+  require "uri"
+  URI.parse(settings.database_url)
+end
+
+def postgres_env_vars(uri)
+  {}.tap do |vars|
+    vars["PGHOST"] = uri.host
+    vars["PGPORT"] = uri.port if uri.port
+    vars["PGUSER"] = uri.user if uri.user
+    vars["PGPASSWORD"] = uri.password if uri.password
+  end
+end
+
+namespace :db do
+  task :setup do
+    <%= config[:camel_cased_app_name] %>::Container.start :rom
+  end
+
+  task :settings do
+    <%= config[:camel_cased_app_name] %>::Container.start :settings
+  end
+
+  desc "Print current database schema version"
+  task version: :setup do
+    version =
+      if db.tables.include?(:schema_migrations)
+        db[:schema_migrations].order(:filename).last[:filename]
+      else
+        "not available"
+      end
+
+    puts "Current schema version: #{version}"
+  end
+
+  desc "Create database"
+  task create: :settings do
+    if system("which createdb", out: File::NULL)
+      uri = database_uri
+      system(postgres_env_vars(uri), "createdb #{Shellwords.escape(uri.path[1..-1])}")
+    else
+      puts "You must have Postgres installed to create a database"
+      exit 1
+    end
+  end
+
+  desc "Drop database"
+  task drop: :settings do
+    if system("which dropdb", out: File::NULL)
+      uri = database_uri
+      system(postgres_env_vars(uri), "dropdb #{Shellwords.escape(uri.path[1..-1])}")
+    else
+      puts "You must have Postgres installed to drop a database"
+      exit 1
+    end
+  end
+
+  desc "Migrate database up to latest migration available"
+  task :migrate do
+    # Enhance the migration task provided by ROM
+
+    # Once it finishes, dump the db structure
+    Rake::Task["db:structure:dump"].execute
+
+    # And print the current migration version
+    Rake::Task["db:version"].execute
+  end
+
+  namespace :structure do
+    desc "Dump database structure to db/structure.sql"
+    task :dump do
+      if system("which pg_dump", out: File::NULL)
+        uri = database_uri
+        system(postgres_env_vars(uri), "pg_dump -s -x -O #{Shellwords.escape(uri.path[1..-1])}", out: "db/structure.sql")
+      else
+        puts "You must have pg_dump installed to dump the database structure"
+      end
+    end
+  end
+
+  desc "Load seed data into the database"
+  task :seed do
+    seed_data = File.join("db", "seed.rb")
+    load(seed_data) if File.exist?(seed_data)
+  end
+
+  desc "Load a small, representative set of data so that the application can start in a useful state (for development)."
+  task :sample_data do
+    sample_data = File.join("db", "sample_data.rb")
+    load(sample_data) if File.exist?(sample_data)
+  end
+end