daidan 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da756040fd2fcaebe748b6533b4216bcb25aae4a554c018e81e05380b4e721e4
+  data.tar.gz: 634513d9b7ce3588e35155ddfaee1dfafa83ccac14b6b866d6373417d42ba4ee
+SHA512:
+  metadata.gz: a13f2d9507e15a8a8810e802766f25a614d9a005d424efe7413d9415a23b57a856a1a408099af54132103bcda77dc581a7fb8b2818c1b73c54237e7acf621aef
+  data.tar.gz: e63537fab9ec1ad7d94b0f3d5191e211d66a46bd99a6eab7de6c72557146c0efee4551f7cc319b736a1f6f852b5043e7292881fa64dad31b39cb52ba09dac005

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## [0.1.0] - YYYY-MM-DD
+
+- Initial release with core features:
+  - GraphQL schema support
+  - Resource generator for models, migrations, and types
+  - Middleware for JWT authentication
+  - Database connection handling

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'bcrypt'
+gem 'dotenv'
+gem 'graphql'
+gem 'jwt'
+gem 'rake'
+gem 'sequel'
+gem 'zeitwerk'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    daidan (0.1.0)
+      bcrypt (~> 3.1)
+      dotenv (~> 3.1)
+      graphql (~> 2.4)
+      jwt (~> 2.9)
+      sequel (~> 5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base64 (0.2.0)
+    bcrypt (3.1.20)
+    bigdecimal (3.1.8)
+    dotenv (3.1.7)
+    fiber-storage (1.0.0)
+    graphql (2.4.8)
+      base64
+      fiber-storage
+    jwt (2.9.3)
+      base64
+    rake (13.2.1)
+    sequel (5.87.0)
+      bigdecimal
+    zeitwerk (2.7.1)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  bcrypt
+  daidan!
+  dotenv
+  graphql
+  jwt
+  rake
+  sequel
+  zeitwerk
+
+BUNDLED WITH
+   2.5.23

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Bernard Cesarz
+
+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,41 @@
+# Daidan
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/daidan`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/daidan.
+
+
+## NOTES
+
+### MIGRATIONS:
+`sequel sqlite://db.db -m db/migrations`

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'daidan'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/daidan

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: daidan [command] [arguments]'
+end
+
+parser.order!
+command = ARGV.shift
+
+if command == 'new'
+  require_relative '../lib/daidan/generators/base_generator'
+
+  app_name = ARGV.shift
+  if app_name.nil? || app_name.strip.empty?
+    puts 'Usage: daidan new app_name'
+    exit 1
+  end
+  Daidan::Generators::BaseGenerator.new(app_name).generate
+  exit 0
+else
+  require_relative '../lib/daidan'
+
+  if command.nil?
+    puts parser
+    exit 1
+  end
+
+  if Daidan::Commands.respond_to?(command)
+    Daidan::Commands.public_send(command, *ARGV)
+  else
+    puts "Unknown command: #{command}"
+    exit 1
+  end
+end

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/daidan.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = 'daidan'
+  spec.version = '0.1.0'
+  spec.authors = ['Bernard Cesarz']
+  spec.email = ['cesarzb@protonmail.com']
+
+  spec.summary = 'Lightweight GraphQL web framework.'
+  spec.description = 'A lightweight Ruby framework for building GraphQL-based web applications.'
+  spec.homepage = 'https://github.com/cesarzb/daidan'
+  spec.licenses = ['MIT']
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = 'https://github.com/cesarzb/daidan/blob/main/CHANGELOG.md'
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['license_uri'] = 'https://opensource.org/licenses/MIT'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |file|
+      file.start_with?('test/', 'spec/', 'features/', '.git/') || file.end_with?('.gem')
+    end
+  end
+
+  spec.bindir = 'bin'
+  spec.executables = spec.files.grep(%r{\Abin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'bcrypt', '~> 3.1'
+  spec.add_dependency 'dotenv', '~> 3.1'
+  spec.add_dependency 'graphql', '~> 2.4'
+  spec.add_dependency 'jwt', '~> 2.9'
+  spec.add_dependency 'sequel', '~> 5.0'
+
+  spec.add_development_dependency 'rake', '~> 13.0'
+end

data/lib/daidan/commands.rb

@@ -0,0 +1,36 @@
+module Daidan
+  module Commands
+    def self.create_base_user
+      require_relative 'db/connection'
+      require_relative 'config/application'
+      Daidan::Db::Connection.setup
+
+      Sequel::Model.db.transaction do
+        Sequel.migration do
+          change do
+            create_table(:users) do
+              primary_key :id
+              String :name, null: false
+              String :email, null: false, unique: true
+              String :password_digest, null: false
+            end
+          end
+        end.apply(Sequel::Model.db, :up)
+      end
+      puts "Table 'users' created successfully!"
+    rescue Sequel::DatabaseError => e
+      raise unless e.message =~ /table `users` already exists/i
+
+      puts "The 'users' table is already created."
+    end
+
+    def self.generate(resource_name, *fields)
+      require_relative 'db/connection'
+      require_relative 'config/application'
+      Daidan::Db::Connection.setup
+
+      require_relative 'generators/resource_generator'
+      Daidan::Generators::ResourceGenerator.new(resource_name, fields).generate
+    end
+  end
+end

data/lib/daidan/config/application.rb

@@ -0,0 +1,75 @@
+module Daidan
+  class Application
+    def initialize
+      setup_zeitwerk
+      super
+    end
+
+    def call(env)
+      process_request(env)
+    rescue JSON::ParserError
+      handle_json_parse_error
+    rescue StandardError => e
+      handle_internal_server_error(e)
+    end
+
+    protected
+
+    def process_request(env)
+      req = Rack::Request.new(env)
+
+      if req.post? && req.path == '/graphql'
+        handle_graphql_request(req, env)
+      else
+        not_found_response
+      end
+    end
+
+    def graphql_schema
+      raise NotImplementedError, 'Subclasses must define `graphql_schema`'
+    end
+
+    def handle_json_parse_error
+      [400, { 'content-type' => 'application/json' }, [{ error: 'Invalid JSON' }.to_json]]
+    end
+
+    def handle_internal_server_error(error)
+      puts "Error processing request: #{error.message}"
+      [500, { 'content-type' => 'application/json' }, [{ error: 'Internal Server Error' }.to_json]]
+    end
+
+    def not_found_response
+      [404, { 'content-type' => 'text/plain' }, ['Not Found']]
+    end
+
+    def setup_zeitwerk
+      app_root = Dir.pwd
+
+      loader = Zeitwerk::Loader.new
+      loader.push_dir(File.join(app_root, ''))
+      loader.collapse(File.join(app_root, 'graphql'))
+      loader.collapse(File.join(app_root, 'graphql', 'types'))
+      loader.collapse(File.join(app_root, 'graphql', 'mutations'))
+      loader.collapse(File.join(app_root, 'models'))
+      loader.setup
+    end
+
+    private
+
+    def handle_graphql_request(req, env)
+      body = req.body.read
+      params = body.empty? ? {} : JSON.parse(body)
+
+      current_user = env['current_user_id'] ? User.find(id: env['current_user_id']) : nil
+
+      result = graphql_schema.execute(
+        params['query'],
+        variables: params['variables'],
+        context: { current_user: current_user },
+        operation_name: params['operationName']
+      )
+
+      [200, { 'content-type' => 'application/json' }, [result.to_json]]
+    end
+  end
+end

data/lib/daidan/db/connection.rb

@@ -0,0 +1,14 @@
+module Daidan
+  module Db
+    class Connection
+      def self.setup(config_path = File.join(Dir.pwd, 'config', 'database.yml'))
+        @db ||= begin
+          db_config = YAML.load_file(config_path)['db']
+          Sequel.connect(db_config).tap do |db|
+            Sequel::Model.db = db
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daidan/db/create_base_user_migration.rb

@@ -0,0 +1,10 @@
+Sequel.migration do
+  change do
+    create_table(:users) do
+      primary_key :id
+      String :name, null: false
+      String :email, null: false, unique: true
+      String :password_digest, null: false
+    end
+  end
+end

data/lib/daidan/generators/base_generator.rb

@@ -0,0 +1,158 @@
+require 'fileutils'
+
+module Daidan
+  module Generators
+    class BaseGenerator
+      def initialize(app_name)
+        @app_name = app_name.strip
+        validate_app_name
+      end
+
+      def generate
+        create_directories
+        create_files
+        puts "✅ Created new app: #{@app_name}"
+      end
+
+      private
+
+      def validate_app_name
+        return if @app_name.match?(/\A[a-z0-9_]+\z/)
+
+        puts "Invalid app name '#{@app_name}'. Use lowercase letters, numbers and underscores only."
+        exit 1
+      end
+
+      def create_directories
+        dirs = [
+          "./#{@app_name}/config",
+          "./#{@app_name}/db/migrations",
+          "./#{@app_name}/graphql/mutations",
+          "./#{@app_name}/graphql/types",
+          "./#{@app_name}/models"
+        ]
+        dirs.each { |d| FileUtils.mkdir_p(d) }
+      end
+
+      def create_files
+        create_application_rb
+        create_database_yml
+        create_config_ru
+        create_gemfile
+        create_schema_rb
+        create_mutation_type_rb
+        create_query_type_rb
+        create_readme
+      end
+
+      def create_application_rb
+        content = <<~RUBY
+          class Application < Daidan::Application
+            def graphql_schema
+              Schema
+            end
+          end
+        RUBY
+        write_file('config/application.rb', content)
+      end
+
+      def create_database_yml
+        content = <<~YAML
+          db:
+            adapter: sqlite
+            database: db.db
+        YAML
+        write_file('config/database.yml', content)
+      end
+
+      def create_config_ru
+        content = <<~RUBY
+          require 'rack'
+          require 'rack/cors'
+          require 'daidan'
+          require_relative 'config/application'
+
+          use Rack::Reloader, 0
+
+          use Rack::Cors do
+            allow do
+              origins '*'
+
+              resource '/graphql',
+                       headers: :any,
+                       methods: %i[get post options],
+                       credentials: false
+            end
+          end
+
+          run Application.new
+        RUBY
+        write_file('config.ru', content)
+      end
+
+      def create_gemfile
+        content = <<~RUBY
+          source 'https://rubygems.org'
+
+          gem 'bcrypt'
+          gem 'dotenv'
+          gem 'graphql'
+          gem 'jwt'
+          gem 'puma'
+          gem 'rack'
+          gem 'rubocop'
+          gem 'sequel'
+          gem 'sqlite3'
+          gem 'zeitwerk'
+          gem 'rack-cors'
+
+          gem 'daidan', path: '../daidan'
+        RUBY
+        write_file('Gemfile', content)
+      end
+
+      def create_schema_rb
+        content = <<~RUBY
+          class Schema < GraphQL::Schema
+            query(QueryType)
+            mutation(MutationType)
+          end
+        RUBY
+        write_file('graphql/schema.rb', content)
+      end
+
+      def create_mutation_type_rb
+        content = <<~RUBY
+          class MutationType < Daidan::BaseObjectType
+            description 'The mutation root of this schema'
+          end
+        RUBY
+        write_file('graphql/types/mutation_type.rb', content)
+      end
+
+      def create_query_type_rb
+        content = <<~RUBY
+          class QueryType < Daidan::BaseObjectType
+            description 'The query root of this schema'
+          end
+        RUBY
+        write_file('graphql/types/query_type.rb', content)
+      end
+
+      def create_readme
+        content = <<~MD
+          # Readme
+
+          Write something about your project here.
+        MD
+        write_file('readme.md', content)
+      end
+
+      def write_file(relative_path, content)
+        full_path = File.join("./#{@app_name}", relative_path)
+        FileUtils.mkdir_p(File.dirname(full_path))
+        File.write(full_path, content)
+      end
+    end
+  end
+end

data/lib/daidan/generators/resource_generator.rb

@@ -0,0 +1,258 @@
+require 'fileutils'
+
+module Daidan
+  module Generators
+    class ResourceGenerator
+      VALID_TYPES = %w[string decimal float integer].freeze
+
+      def initialize(resource, fields)
+        @resource = resource.downcase
+        @class_name = @resource.capitalize
+        @fields = fields
+      end
+
+      def generate
+        parse_fields(@fields)
+        validate_inputs
+        generate_migration
+        generate_model
+        generate_mutations
+        generate_type
+        inject_mutation_type
+        inject_query_type
+        puts "✅ Generated resource: #{@resource}"
+      end
+
+      private
+
+      def parse_fields(fields)
+        @parsed_fields = fields.map do |f|
+          name, type = f.split(':', 2)
+          unless name && type && !name.empty? && !type.empty?
+            puts "Invalid field specification #{f}. Use name:type."
+            exit 1
+          end
+          unless name.match?(/\A[a-z_]+\z/)
+            puts "Invalid field name '#{name}'. Use lowercase letters and underscores only."
+            exit 1
+          end
+          unless VALID_TYPES.include?(type)
+            puts "Invalid field type '#{type}'. Allowed types: #{VALID_TYPES.join(', ')}."
+            exit 1
+          end
+          [name, type]
+        end
+      end
+
+      def validate_inputs
+        return if @resource.match?(/\A[a-z_]+\z/)
+
+        puts 'Invalid resource name. Use lowercase letters and underscores only.'
+        exit 1
+      end
+
+      def db_type_map
+        map = {
+          'string' => 'String',
+          'decimal' => 'Decimal',
+          'float' => 'Float',
+          'integer' => 'Integer'
+        }
+        map.default = 'String'
+        map
+      end
+
+      def graphql_type_map
+        map = {
+          'string' => 'String',
+          'decimal' => 'Float',
+          'float' => 'Float',
+          'integer' => 'Int'
+        }
+        map.default = 'String'
+        map
+      end
+
+      def generate_migration
+        migrations_dir = File.join('.', 'db', 'migrations')
+        FileUtils.mkdir_p(migrations_dir)
+        existing = Dir[File.join(migrations_dir, '*.rb')]
+        numbers = existing.map { |f| File.basename(f).split('_', 2).first.to_i }
+        next_number = numbers.empty? ? 1 : numbers.max + 1
+        migration_name = "create_#{@resource}s"
+        table_name = "#{@resource}s"
+        migration_file = File.join(migrations_dir, format("%03d_#{migration_name}.rb", next_number))
+
+        fields = @parsed_fields.map do |(name, type)|
+          db_t = db_type_map[type]
+          null_part = ', null: false'
+          size_part = type == 'decimal' ? ', size: [10, 2]' : ''
+          "      #{db_t} :#{name}#{size_part}#{null_part}"
+        end.join("\n")
+
+        migration_content = <<~RUBY
+          Sequel.migration do
+            change do
+              create_table(:#{table_name}) do
+                primary_key :id
+          #{fields}
+              end
+            end
+          end
+        RUBY
+
+        File.write(migration_file, migration_content)
+      end
+
+      def generate_model
+        models_dir = File.join('.', 'models')
+        FileUtils.mkdir_p(models_dir)
+        model_file = File.join(models_dir, "#{@resource}.rb")
+
+        model_content = <<~RUBY
+          class #{@class_name} < Sequel::Model
+            set_dataset :#{@resource}s
+          end
+        RUBY
+
+        File.write(model_file, model_content)
+      end
+
+      def generate_mutations
+        mutations_dir = File.join('.', 'graphql', 'mutations')
+        FileUtils.mkdir_p(mutations_dir)
+
+        create_args = @parsed_fields.map do |(name, type)|
+          gtype = graphql_type_map[type]
+          "  argument :#{name}, #{gtype}, required: true"
+        end.join("\n")
+
+        update_args = @parsed_fields.map do |(name, type)|
+          gtype = graphql_type_map[type]
+          "  argument :#{name}, #{gtype}, required: false"
+        end.join("\n")
+
+        create_mutation_file = File.join(mutations_dir, "create_#{@resource}.rb")
+        create_mutation_content = <<~RUBY
+          class Create#{@class_name} < Daidan::BaseMutation
+          #{create_args}
+
+            type #{@class_name}Type
+
+            def resolve(#{@parsed_fields.map { |f| "#{f[0]}:" }.join(', ')})
+              #{@class_name}.create(#{@parsed_fields.map { |(n, t)| "#{n}: #{n}" }.join(', ')})
+            rescue Sequel::Error => e
+              GraphQL::ExecutionError.new("Unable to create #{@resource}: \#{e.message}")
+            end
+          end
+        RUBY
+        File.write(create_mutation_file, create_mutation_content)
+
+        update_mutation_file = File.join(mutations_dir, "update_#{@resource}.rb")
+        update_mutation_content = <<~RUBY
+          class Update#{@class_name} < Daidan::BaseMutation
+            argument :id, ID, required: true
+          #{update_args}
+
+            type #{@class_name}Type
+
+            def resolve(id:, **attributes)
+              record = #{@class_name}[id]
+              raise GraphQL::ExecutionError, '#{@class_name} not found' unless record
+
+              attributes.each do |k,v|
+                record.update(k => v) if v
+              end
+
+              record
+            rescue Sequel::Error => e
+              GraphQL::ExecutionError.new("Unable to update #{@resource}: \#{e.message}")
+            end
+          end
+        RUBY
+        File.write(update_mutation_file, update_mutation_content)
+
+        delete_mutation_file = File.join(mutations_dir, "delete_#{@resource}.rb")
+        delete_mutation_content = <<~RUBY
+          class Delete#{@class_name} < Daidan::BaseMutation
+            argument :id, ID, required: true
+
+            type #{@class_name}Type
+
+            def resolve(id:)
+              record = #{@class_name}[id]
+              raise GraphQL::ExecutionError, '#{@class_name} not found' unless record
+
+              record.destroy
+              record
+            rescue Sequel::Error => e
+              GraphQL::ExecutionError.new("Unable to delete #{@resource}: \#{e.message}")
+            end
+          end
+        RUBY
+        File.write(delete_mutation_file, delete_mutation_content)
+      end
+
+      def generate_type
+        types_dir = File.join('.', 'graphql', 'types')
+        FileUtils.mkdir_p(types_dir)
+        type_file = File.join(types_dir, "#{@resource}_type.rb")
+
+        type_fields = @parsed_fields.map do |(name, type)|
+          gtype = graphql_type_map[type]
+          "  field :#{name}, #{gtype}, null: false"
+        end.join("\n")
+
+        type_content = <<~RUBY
+          class #{@class_name}Type < Daidan::BaseObjectType
+          #{type_fields}
+          end
+        RUBY
+
+        File.write(type_file, type_content)
+      end
+
+      def inject_mutation_type
+        mutation_type_file = File.join('.', 'graphql', 'types', 'mutation_type.rb')
+        return unless File.exist?(mutation_type_file)
+
+        lines = File.read(mutation_type_file).lines
+        i = lines.rindex { |l| l.strip == 'end' }
+        return unless i
+
+        insert_lines = [
+          "  field :create_#{@resource}, mutation: Create#{@class_name}",
+          "  field :update_#{@resource}, mutation: Update#{@class_name}",
+          "  field :delete_#{@resource}, mutation: Delete#{@class_name}"
+        ]
+        lines.insert(i, *insert_lines.map { |l| l + "\n" })
+        File.write(mutation_type_file, lines.join)
+      end
+
+      def inject_query_type
+        query_type_file = File.join('.', 'graphql', 'types', 'query_type.rb')
+        return unless File.exist?(query_type_file)
+
+        lines = File.read(query_type_file).lines
+        i = lines.rindex { |l| l.strip == 'end' }
+        return unless i
+
+        field_lines = [
+          "  field :#{@resource}s, [#{@class_name}Type], null: false do",
+          "    description 'Retrieve a list of #{@resource}s'",
+          '  end'
+        ]
+        lines.insert(i, *field_lines.map { |l| l + "\n" })
+
+        def_lines = [
+          "  def #{@resource}s",
+          "    #{@class_name}.all",
+          '  end'
+        ]
+        lines.insert(i + field_lines.size, *def_lines.map { |l| l + "\n" })
+
+        File.write(query_type_file, lines.join)
+      end
+    end
+  end
+end

data/lib/daidan/graphql/mutations/base_mutation.rb

@@ -0,0 +1,4 @@
+module Daidan
+  class BaseMutation < GraphQL::Schema::Mutation
+  end
+end

data/lib/daidan/graphql/mutations/login_user.rb

@@ -0,0 +1,20 @@
+module Daidan
+  class LoginUser < BaseMutation
+    argument :email, String, required: true
+    argument :password, String, required: true
+
+    field :token, String, null: false
+    field :user, BaseUserType, null: false
+
+    def resolve(email:, password:)
+      user = User.where(email: email).first
+
+      raise GraphQL::ExecutionError, 'Invalid email or password' unless user && user.authenticate(password)
+
+      payload = { user_id: user.id }
+
+      token = JWT.encode(payload, ENV['JWT_SECRET'], 'HS256')
+      { token: token, user: user }
+    end
+  end
+end

data/lib/daidan/graphql/types/base_object_type.rb

@@ -0,0 +1,5 @@
+module Daidan
+  class BaseObjectType < GraphQL::Schema::Object
+    field :id, ID, null: false
+  end
+end

data/lib/daidan/graphql/types/base_user_type.rb

@@ -0,0 +1,5 @@
+module Daidan
+  class BaseUserType < Daidan::BaseObjectType
+    field :email, String, null: false
+  end
+end

data/lib/daidan/middleware/jwt_authentication.rb

@@ -0,0 +1,27 @@
+module Daidan
+  module Middleware
+    class JwtAuthentication
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        auth_header = env['HTTP_AUTHORIZATION']
+        if auth_header && auth_header.start_with?('Bearer ')
+          token = auth_header.split(' ').last
+
+          begin
+            payload, = JWT.decode(token, ENV['JWT_SECRET'], true, { algorithm: 'HS256' })
+            env['current_user_id'] = payload['user_id']
+          rescue JWT::DecodeError
+            env['current_user_id'] = nil
+          end
+        else
+          env['current_user_id'] = nil
+        end
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/daidan/models/user.rb

@@ -0,0 +1,34 @@
+module Daidan
+  class User < Sequel::Model
+    include BCrypt
+    attr_accessor :password
+
+    set_dataset :users
+
+    plugin :validation_helpers
+
+    def before_save
+      super
+      encrypt_password if password
+    end
+
+    def validate
+      super
+      validates_presence %i[email], message: 'is required'
+      validates_unique :email, message: 'is already taken'
+      validates_format(/\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i, :email, message: 'is not a valid email address')
+      errors.add(:password, 'cannot be empty') if new? && !password
+      errors.add(:password, 'must be at least 6 characters') if password && password.length < 6
+    end
+
+    def authenticate(submitted_password)
+      Password.new(password_digest) == submitted_password
+    end
+
+    private
+
+    def encrypt_password
+      self.password_digest = Password.create(password)
+    end
+  end
+end

data/lib/daidan/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Daidan
+  VERSION = "0.1.0"
+end

data/lib/daidan.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bcrypt'
+require 'dotenv/load'
+require 'graphql'
+require 'json'
+require 'jwt'
+require 'rack'
+require 'sequel'
+require 'yaml'
+require 'zeitwerk'
+
+require_relative 'daidan/version'
+require_relative 'daidan/db/connection'
+require_relative 'daidan/config/application'
+
+Daidan::Db::Connection.setup
+require_relative 'daidan/commands'
+
+require_relative 'daidan/middleware/jwt_authentication'
+require_relative 'daidan/graphql/mutations/base_mutation'
+require_relative 'daidan/graphql/types/base_object_type'
+require_relative 'daidan/graphql/types/base_user_type'
+require_relative 'daidan/graphql/mutations/login_user'
+
+module Daidan
+  autoload :User, 'daidan/models/user'
+
+  class Error < StandardError; end
+end

data/sig/daidan.rbs

@@ -0,0 +1,3 @@
+module Daidan
+  VERSION: String
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: daidan
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+original_platform: ''
+authors:
+- Bernard Cesarz
+bindir: bin
+cert_chain: []
+date: 2024-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A lightweight Ruby framework for building GraphQL-based web applications.
+email:
+- cesarzb@protonmail.com
+executables:
+- console
+- daidan
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/daidan
+- bin/setup
+- daidan.gemspec
+- lib/daidan.rb
+- lib/daidan/commands.rb
+- lib/daidan/config/application.rb
+- lib/daidan/db/connection.rb
+- lib/daidan/db/create_base_user_migration.rb
+- lib/daidan/generators/base_generator.rb
+- lib/daidan/generators/resource_generator.rb
+- lib/daidan/graphql/mutations/base_mutation.rb
+- lib/daidan/graphql/mutations/login_user.rb
+- lib/daidan/graphql/types/base_object_type.rb
+- lib/daidan/graphql/types/base_user_type.rb
+- lib/daidan/middleware/jwt_authentication.rb
+- lib/daidan/models/user.rb
+- lib/daidan/version.rb
+- sig/daidan.rbs
+homepage: https://github.com/cesarzb/daidan
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/cesarzb/daidan
+  source_code_uri: https://github.com/cesarzb/daidan
+  changelog_uri: https://github.com/cesarzb/daidan/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  license_uri: https://opensource.org/licenses/MIT
+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.6.1
+specification_version: 4
+summary: Lightweight GraphQL web framework.
+test_files: []