mayu-live 0.0.0

data/lib/mayu/component.rb

@@ -0,0 +1,54 @@
+# typed: strict
+
+require_relative "vdom/interfaces"
+require_relative "component/wrapper"
+require_relative "component/base"
+
+module Mayu
+  module Component
+    extend T::Sig
+
+    Props = T.type_alias { T::Hash[Symbol, T.untyped] }
+    State = T.type_alias { T::Hash[Symbol, T.untyped] }
+
+    LambdaComponent =
+      T.type_alias do
+        T
+          .proc
+          .params(kwargs: Props)
+          .returns(T.nilable(VDOM::Interfaces::Descriptor))
+      end
+
+    ComponentType = T.type_alias { T.any(T.class_of(Base), LambdaComponent) }
+
+    Children = T.type_alias { T.any(ChildType, T::Array[ChildType]) }
+
+    ChildType =
+      T.type_alias do
+        T.nilable(
+          T.any(VDOM::Interfaces::Descriptor, T::Boolean, String, Numeric)
+        )
+      end
+
+    ElementType = T.type_alias { T.any(Symbol, ComponentType) }
+
+    sig { params(other: T.untyped).returns(T::Boolean) }
+    def self.===(other)
+      component_class?(other)
+    end
+
+    sig { params(klass: T.untyped).returns(T::Boolean) }
+    def self.component_class?(klass)
+      !!(klass.is_a?(Class) && klass < Base)
+    end
+
+    sig do
+      params(vnode: VDOM::VNode, type: T.untyped, props: Props).returns(
+        T.nilable(Wrapper)
+      )
+    end
+    def self.wrap(vnode, type, props)
+      component_class?(type) ? Wrapper.new(vnode, type, props) : nil
+    end
+  end
+end

data/lib/mayu/configuration.rb

@@ -0,0 +1,195 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "toml-rb"
+require "async/container"
+
+module Mayu
+  class Configuration < T::Struct
+    extend T::Sig
+
+    CONFIG_FILE = "mayu.toml"
+
+    class Server < T::Struct
+      extend T::Sig
+
+      const :scheme, String, default: "https"
+      const :host, String, default: "127.0.0.1"
+      const :port, Integer, default: 9292
+
+      const :hot_swap, T::Boolean, default: false
+      const :self_signed_cert, T::Boolean, default: false
+
+      const :generate_assets, T::Boolean, default: false
+
+      const :render_exceptions, T::Boolean, default: false
+
+      const :count, Integer, default: Async::Container.processor_count
+      const :forks, T.nilable(Integer)
+      const :threads, T.nilable(Integer)
+
+      sig { returns(URI::HTTP) }
+      def uri
+        URI.for(scheme, nil, host, port, nil, "/", nil, nil, nil).normalize
+      end
+    end
+
+    class Instance < T::Struct
+      const :app_name, String, default: ENV.fetch("FLY_APP_NAME", "mayu-live")
+      const :region, String, default: ENV.fetch("FLY_REGION", "dev")
+      const :alloc_id,
+            String,
+            default:
+              ENV.fetch("FLY_ALLOC_ID", "00000000-0000-0000-0000-000000000000")
+    end
+
+    class Paths < T::Struct
+      const :components, String, default: "components"
+      const :pages, String, default: "pages"
+      const :stores, String, default: "stores"
+      const :public, String, default: "public"
+      const :assets, String, default: ".assets"
+      const :dist, String, default: "dist"
+      const :bundle_filename, String, default: "app.mayu-bundle"
+    end
+
+    class Metrics < T::Struct
+      const :enabled, T::Boolean, default: false
+      const :port, Integer, default: 9091
+      const :host, String, default: "127.0.0.1"
+      const :path, String, default: "/metrics"
+    end
+
+    const :mode, Symbol
+    const :root, String
+    const :secret_key, String
+    const :use_bundle, T::Boolean, default: false
+
+    const :server, Server, default: Server.new
+    const :metrics, Metrics, default: Metrics.new
+    const :paths, Paths, default: Paths.new
+    const :instance, Instance, default: Instance.new
+
+    sig { params(dir: String).returns(String) }
+    def self.resolve_config_file(dir = Dir.pwd)
+      path = File.join(dir, CONFIG_FILE)
+
+      return path if File.file?(path)
+
+      parent = File.expand_path("..", dir)
+
+      if dir == parent
+        raise "Could not find #{CONFIG_FILE} in any parent directory."
+      end
+
+      resolve_config_file(parent)
+    end
+
+    sig do
+      params(
+        mode: Symbol,
+        pwd: String,
+        overrides: T::Hash[String, T.untyped]
+      ).returns(T.attached_class)
+    end
+    def self.load_config(mode, pwd: Dir.pwd, overrides: {})
+      file = resolve_config_file(pwd)
+      root = File.dirname(file)
+
+      config =
+        T.cast(
+          TomlRB.load_file(file),
+          T::Hash[String, T::Hash[String, T.untyped]]
+        )
+
+      base_config = config.dig("base") || {}
+      env_config = config.dig(mode.to_s) || {}
+
+      merged_config = base_config.merge(env_config).merge(overrides)
+
+      secret_key =
+        merged_config.fetch("secret_key") do
+          ENV.fetch("MAYU_SECRET_KEY") do
+            raise "secret_key is not configured (can be set with env var MAYU_SECRET_KEY)"
+          end
+        end
+
+      from_hash!(
+        {
+          **merged_config,
+          "root" => root,
+          "secret_key" => secret_key,
+          "mode" => mode
+        }
+      )
+    end
+
+    sig { params(configuration: T::Struct).void }
+    def self.log_config(configuration)
+      Console.logger.info(self) { make_table(configuration) }
+    end
+
+    sig do
+      params(
+        configuration: T::Struct,
+        style: T::Hash[Symbol, T.untyped]
+      ).returns(String)
+    end
+    def self.make_table(
+      configuration,
+      style: { all_separators: true, border: :unicode }
+    )
+      Terminal::Table
+        .new do |t|
+          t.headings = %w[key value type].map { "\e[1m#{_1}\e[0m" }
+          t.style = style
+
+          configuration.class.props.each do |prop, opts|
+            value =
+              if prop.to_s.start_with?("secret_")
+                "\e[2m***hidden***\e[0m"
+              else
+                case configuration.send(prop)
+                in T::Struct => struct
+                  make_table(struct, style: { border: :unicode_round })
+                in other
+                  colorize_value(other)
+                end
+              end
+
+            t.add_row([prop, value, opts[:type].to_s.delete_prefix("Mayu::")])
+          end
+        end
+        .to_s
+    end
+
+    sig { params(value: T.untyped).returns(String) }
+    def self.colorize_value(value)
+      if color = value_color(value).nonzero?
+        "\e[#{color}m#{value.inspect}\e[0m"
+      else
+        value.inspect
+      end
+    end
+
+    sig { params(value: T.untyped).returns(Integer) }
+    def self.value_color(value)
+      case value
+      when FalseClass
+        31
+      when TrueClass
+        32
+      when String
+        33
+      when Numeric
+        34
+      when Symbol
+        36
+      when nil
+        2
+      else
+        0
+      end
+    end
+  end
+end

data/lib/mayu/disable_sorbet.rb

@@ -0,0 +1,23 @@
+# typed: false
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Mayu
+  module DisableSorbet
+    def self.disable_sorbet!
+      # https://github.com/sorbet/sorbet/issues/3279#issuecomment-679154712
+      T::Configuration.default_checked_level = :never
+
+      error_handler =
+        lambda do |error, *_|
+          # Log error somewhere
+        end
+
+      # Suppresses errors caused by T.cast, T.let, T.must, etc.
+      T::Configuration.inline_type_error_handler = error_handler
+      # Suppresses errors caused by incorrect parameter ordering
+      T::Configuration.sig_validation_error_handler = error_handler
+    end
+  end
+end

data/lib/mayu/environment.rb

@@ -0,0 +1,151 @@
+# typed: strict
+
+require "async"
+require "async/http/internet"
+require_relative "vdom"
+require_relative "state/store"
+require_relative "state/loader"
+require_relative "routes"
+require_relative "metrics"
+require_relative "app_metrics"
+require_relative "resources/registry"
+require_relative "fetch"
+require_relative "message_cipher"
+require_relative "configuration"
+
+module Mayu
+  class Environment
+    # The Environment class is instantiated on startup and contains
+    # configuration and everything that should be shared.
+    extend T::Sig
+
+    PAGES_DIR = "pages"
+    STORE_DIR = "store"
+
+    sig { returns(String) }
+    attr_reader :root
+    sig { returns(Configuration) }
+    attr_reader :config
+    sig { returns(T::Array[Routes::Route]) }
+    attr_reader :routes
+    sig { returns(State::Store::Reducers) }
+    attr_reader :reducers
+    sig { returns(Resources::Registry) }
+    attr_reader :resources
+    sig { returns(Fetch) }
+    attr_reader :fetch
+    sig { returns(MessageCipher) }
+    attr_reader :message_cipher
+    sig { returns(AppMetrics) }
+    attr_reader :metrics
+
+    sig { params(config: Configuration, metrics: AppMetrics).void }
+    def initialize(config, metrics)
+      @root = T.let(config.root, String)
+      @app_root = T.let(File.join(config.root, "app"), String)
+      @config = config
+      @message_cipher =
+        T.let(MessageCipher.new(key: config.secret_key, ttl: 30), MessageCipher)
+      # TODO: Reload routes when things change in /pages...
+      # Should probably make routes into a resource type.
+      @routes =
+        T.let(
+          Routes.build_routes(File.join(@app_root, PAGES_DIR)),
+          T::Array[Routes::Route]
+        )
+      @reducers =
+        T.let(
+          State::Loader.new(File.join(@app_root, STORE_DIR)).load,
+          State::Store::Reducers
+        )
+      @resources =
+        T.let(
+          if @config.use_bundle
+            Resources::Registry.load(
+              File.read(@config.paths.bundle_filename, encoding: "binary"),
+              root:
+            )
+          else
+            Resources::Registry.new(root: @root)
+          end,
+          Resources::Registry
+        )
+      @metrics = metrics
+      @fetch = T.let(Fetch.new, Fetch)
+      @init_js = T.let(nil, T.nilable(String))
+    end
+
+    sig { returns(String) }
+    def init_js
+      @init_js ||=
+        JSON.parse(File.read(File.join(js_runtime_path, "entries.json"))).fetch(
+          "main"
+        )
+    end
+
+    sig { params(name: Symbol).returns(String) }
+    def path(name)
+      File.join(@root, @config.paths.send(name))
+    end
+
+    sig { returns(String) }
+    def js_runtime_path
+      File.join(__dir__, "client", "dist")
+    end
+
+    sig do
+      params(initial_state: T::Hash[Symbol, T.untyped]).returns(State::Store)
+    end
+    def create_store(initial_state: {})
+      State::Store.new(initial_state, reducers:)
+    end
+
+    sig do
+      params(request_path: String, headers: T::Hash[String, String]).returns(
+        VDOM::Descriptor
+      )
+    end
+    def load_root(request_path, headers: {})
+      path, search = request_path.split("?", 2)
+      # We should match the route earlier, so that we don't have to get this
+      # far in case it doesn't match...
+      route_match = match_route(path.to_s)
+      query = Rack::Utils.parse_nested_query(search).transform_keys(&:to_sym)
+      params = route_match.params
+
+      # Load the page component.
+      component_path = File.join("/", "app", "pages", route_match.template)
+      resources.load_resource(component_path).type =>
+        Resources::Types::Component => mod_type
+
+      page_component = mod_type.component
+
+      resources.load_resource(File.join("/", "app", "root")).type =>
+        Resources::Types::Component => root
+
+      request_info = { path:, params:, query:, headers: }.freeze
+
+      # Apply the layouts.
+      # NOTE: Pages should probably be their own
+      # resource type and load their layouts.
+      route_match
+        .layouts
+        .reverse
+        .reduce(VDOM::H[page_component, request: request_info]) do |app, layout|
+          Console.logger.info(self, "Applying layout #{layout.inspect}")
+
+          resources.load_resource(
+            File.join("/", "app", "pages", layout)
+          ).type => Resources::Types::Component => layout
+
+          VDOM::H[layout.component, app, request: request_info]
+        end
+        .then { VDOM::H[root.component, _1] }
+    end
+
+    sig { params(request_path: String).returns(Routes::RouteMatch) }
+    def match_route(request_path)
+      Routes.match_route(@routes, request_path)
+    end
+  end
+end

data/lib/mayu/event_stream.rb

@@ -0,0 +1,158 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "nanoid"
+require "msgpack"
+require "zlib"
+
+module Mayu
+  module EventStream
+    class Writable
+      extend T::Sig
+
+      sig { params(body: Async::HTTP::Body::Writable).void }
+      def initialize(body)
+        @body = body
+        @deflate =
+          T.let(
+            Zlib::Deflate.new(
+              Zlib::BEST_COMPRESSION,
+              -Zlib::MAX_WBITS,
+              Zlib::MAX_MEM_LEVEL,
+              Zlib::HUFFMAN_ONLY
+            ),
+            Zlib::Deflate
+          )
+
+        @wrapper = T.let(EventStream::Wrapper.new, EventStream::Wrapper)
+      end
+
+      sig { params(obj: T.untyped).void }
+      def write(obj)
+        obj
+          .then { @wrapper.pack(_1.to_a) }
+          .then { @deflate.deflate(_1, Zlib::SYNC_FLUSH) }
+          .then { @body.write(_1) }
+      end
+
+      sig { returns(T::Boolean) }
+      def closed?
+        @body.closed?
+      end
+
+      sig { void }
+      def close
+        @body.write(@deflate.flush(Zlib::FINISH))
+        @deflate.close
+        @body.close
+      end
+    end
+
+    class Blob
+      extend T::Sig
+
+      sig { params(data: String).void }
+      def initialize(data)
+        @data = data
+      end
+
+      sig { params(data: String).returns(T.attached_class) }
+      def self.from_msgpack_ext(data)
+        new(data)
+      end
+
+      sig { returns(String) }
+      def to_msgpack_ext
+        @data
+      end
+    end
+
+    class Wrapper < MessagePack::Factory
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super()
+
+        self.register_type(0x01, Blob)
+      end
+    end
+
+    class Message
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :id
+      sig { returns(String) }
+      attr_reader :event
+      sig { returns(T.untyped) }
+      attr_reader :data
+
+      sig { params(event: T.any(String, Symbol), data: T.untyped).void }
+      def initialize(event, data = {})
+        @id = T.let(Nanoid.generate, String)
+        @event = T.let(event.to_s, String)
+        @data = data
+      end
+
+      sig { returns([String, String, T.untyped]) }
+      def to_a
+        [@id, @event, @data]
+      end
+    end
+
+    class Log
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @history = T.let([], T::Array[Message])
+        @queue = T.let(Async::Queue.new, Async::Queue)
+        @wrapper = T.let(Wrapper.new, Wrapper)
+      end
+
+      sig { returns(T::Boolean) }
+      def empty? = @queue.empty?
+
+      sig { returns(Integer) }
+      def size = @queue.size
+
+      sig { params(event: Symbol, data: T.untyped).void }
+      def push(event, data = {})
+        @queue.enqueue(Message.new(event, data))
+      end
+
+      sig { params(id: String).void }
+      def ack(id)
+        if index = @history.map(&:id).index(id)
+          @history.slice!(0..index)
+        end
+      end
+
+      sig { params(last_id: String).returns(T::Array[Message]) }
+      def replay(last_id)
+        ack(last_id)
+        @history.dup
+      end
+
+      sig { returns(Message) }
+      def pop
+        message = @queue.dequeue
+        # There is no ack-functionality in the client so this will just grow anyways..
+        # @history.push(message)
+        message
+      end
+
+      sig { params(message: Message).returns(String) }
+      def pack(message)
+        data = @wrapper.pack(message.to_a)
+        # N = 32-bit unsigned, network (big-endian) byte order
+        # a = arbitrary binary string (null padded, count is width)
+        [data.bytesize, data].pack("N a*")
+      end
+    end
+
+    class Stream
+    end
+  end
+end

data/lib/mayu/fetch.rb

@@ -0,0 +1,88 @@
+# typed: strict
+
+require "bundler/setup"
+require "sorbet-runtime"
+require "async"
+require "async/http/internet"
+require "rack/utils"
+require "pry"
+require "uri"
+
+module Mayu
+  # This class implements a simplified version of the Fetch API.
+  # https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+  class Fetch
+    class Response < T::Struct
+      extend T::Sig
+
+      const :url, String
+      const :body, String
+      const :headers, T::Hash[String, T.any(String, T::Array[String])]
+      const :status, Integer
+      const :status_text, String
+      const :ok, T::Boolean
+      const :redirected, T::Boolean
+
+      alias ok? ok
+      alias redirected? redirected
+
+      sig { params(symbolize_names: T::Boolean).returns(T.untyped) }
+      def json(symbolize_names: false)
+        JSON.parse(body, symbolize_names:)
+      end
+
+      sig { returns(String) }
+      def content_type
+        headers.fetch("content-type").to_s
+      end
+
+      sig { returns(String) }
+      def inspect
+        "<##{self.class.name} url=#{url.inspect} status=#{status.inspect} status_text=#{status_text.inspect} content_type=#{content_type.inspect} body=#{body.bytesize}b>"
+      end
+    end
+
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @internet = T.let(Async::HTTP::Internet.new, Async::HTTP::Internet)
+    end
+
+    sig do
+      params(
+        url: String,
+        method: Symbol,
+        headers: T::Hash[String, String],
+        body: T.nilable(String)
+      ).returns(Response)
+    end
+    def fetch(url, method: :GET, headers: {}, body: nil)
+      puts "\e[35mFETCHING #{url}\e[0m"
+      res = @internet.call(method, url, headers.to_a, body)
+      puts "\e[34mFETCHED #{url}\e[0m"
+
+      Response.new(
+        url:,
+        body: res.read,
+        headers: res.headers.to_h,
+        status: res.status,
+        status_text: Rack::Utils::HTTP_STATUS_CODES[res.status],
+        ok: res.success?,
+        redirected: res.redirection?
+      )
+    rescue => e
+      puts "\e[32mFAILED ON #{url}\e[0m"
+      raise
+    end
+  end
+end
+#
+# Async do
+#   fetch = Mayu::Fetch.new
+#   res =
+#     fetch.fetch(
+#       "https://raw.githubusercontent.com/rack/rack/main/lib/rack/utils.rb"
+#     )
+#   p res
+# end