erupt-sdk 0.1.0

data/lib/erupt/schema.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Erupt
+  # Checks annotation JSON against erupt-annotations.schema.json (the same schema types.rb is generated from),
+  # so a misspelt attribute or an unknown enum value fails when the model is declared instead of silently
+  # doing nothing in the browser.
+  module Schema
+    DEFS = JSON.parse(File.read(File.join(__dir__, "schema.json")))["$defs"]
+
+    PRIMITIVES = {
+      "string" => ->(v) { v.is_a?(String) },
+      "integer" => ->(v) { v.is_a?(Integer) },
+      "number" => ->(v) { v.is_a?(Numeric) },
+      "boolean" => ->(v) { v == true || v == false }
+    }.freeze
+
+    module_function
+
+    def enum_values(name) = DEFS.fetch(name).fetch("enum")
+
+    # The declared defaults of an annotation, as Java fills an attribute left out.
+    def defaults(name) = DEFS.fetch(name)["properties"].each_with_object({}) { |(k, v), h| h[k] = v["default"] if v.key?("default") }
+
+    # Raise ArgumentError unless +value+ fits definition +name+. +partial+ (an override) lets every attribute
+    # be omitted; otherwise the attributes the Java side always emits must be present.
+    def check(name, value, path = name, partial: true)
+      walk({ "$ref" => "#/$defs/#{name}" }, value, path, partial)
+    end
+
+    def walk(schema, value, path, partial)
+      return walk_ref(schema["$ref"].split("/").last, value, path, partial) if schema["$ref"]
+
+      kind = schema["type"]
+      case kind
+      when "array"
+        raise ArgumentError, "#{path}: expected an array" unless value.is_a?(Array)
+
+        value.each_with_index { |item, i| walk(schema["items"], item, "#{path}[#{i}]", partial) }
+      when "object"
+        raise ArgumentError, "#{path}: expected an object" unless value.is_a?(Hash)
+
+        value.each { |k, item| walk(schema["additionalProperties"], item, "#{path}.#{k}", partial) } if schema["additionalProperties"]
+      else
+        raise ArgumentError, "#{path}: expected #{kind}, got #{JSON.generate(value)}" unless PRIMITIVES.fetch(kind).call(value)
+      end
+    end
+
+    def walk_ref(name, value, path, partial)
+      d = DEFS.fetch(name)
+      if d["enum"]
+        return if d["enum"].include?(value)
+
+        raise ArgumentError, "#{path}: '#{value}' is not a #{name}, expected one of #{d["enum"].join(", ")}"
+      end
+      raise ArgumentError, "#{path}: expected an object (#{name})" unless value.is_a?(Hash)
+
+      value.each do |key, item|
+        raise ArgumentError, "#{path}: #{name} has no attribute '#{key}'" unless d["properties"].key?(key)
+
+        walk(d["properties"][key], item, "#{path}.#{key}", partial)
+      end
+      missing = partial ? [] : (d["required"] || []) - value.keys
+      raise ArgumentError, "#{path}: missing #{missing.join(", ")}" unless missing.empty?
+    end
+  end
+end

data/lib/erupt/signature.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Erupt
+  # Erupt-Signature (erupt-cloud/PROTOCOL.md §4.3): an HMAC-SHA256 the server puts on every forward, keyed by
+  # the node's access token, so the token need not travel and the signed headers cannot be forged.
+  module Signature
+    WINDOW_SECONDS = 300
+    UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD"
+
+    module_function
+
+    # +body+ is the raw bytes, or nil for a multipart upload the server re-encodes (not covered).
+    def sign(access_token, method, path_and_query, timestamp, enforced, user, body)
+      canonical = [method.upcase, path_and_query, timestamp.to_s, enforced.to_s, sha256(user.to_s),
+                   body.nil? ? UNSIGNED_PAYLOAD : sha256(body)].join("\n")
+      OpenSSL::HMAC.hexdigest("SHA256", access_token, canonical)
+    end
+
+    def verify(access_token, method, path_and_query, timestamp, enforced, user, body, signature, now)
+      ts = Integer(timestamp.to_s.strip, 10, exception: false)
+      return false if ts.nil? || (now - ts).abs > WINDOW_SECONDS
+
+      OpenSSL.secure_compare(sign(access_token, method, path_and_query, ts, enforced, user, body), signature.to_s.strip)
+    end
+
+    def sha256(data) = OpenSSL::Digest::SHA256.hexdigest(data)
+  end
+end

data/lib/erupt/sql.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Erupt
+  # What SqlRepository needs from a database: +call(sql, params)+ runs one statement with bound values and
+  # returns the rows of a SELECT as hashes keyed by column name; +dialect+ (:sqlite, :postgres, :mysql) picks
+  # identifier quotes, placeholders and LIKE. The SDK depends on no driver: the adapters below only call the
+  # driver object they are handed, and any other library takes a block:
+  #
+  #   Erupt::SqlExecutor.new(:postgres) do |sql, params|
+  #     ActiveRecord::Base.connection_pool.with_connection { |c| c.raw_connection.exec_params(sql, params).to_a }
+  #   end
+  class SqlExecutor
+    DIALECTS = %i[sqlite postgres mysql].freeze
+
+    attr_reader :dialect
+
+    def initialize(dialect, &run)
+      @dialect = dialect.to_sym
+      raise ArgumentError, "dialect must be one of #{DIALECTS.join(", ")}" unless DIALECTS.include?(@dialect)
+
+      @run = run or raise ArgumentError, "a block running (sql, params) is required"
+    end
+
+    def call(sql, params) = @run.call(sql, params)
+
+    # pg gem: a PG::Connection, or a ConnectionPool of them.
+    def self.pg(db) = adapter(:postgres, db) { |c, sql, params| c.exec_params(sql, params).to_a }
+
+    # mysql2 gem: a Mysql2::Client, or a ConnectionPool of them; statements are prepared, so values are bound.
+    def self.mysql2(db)
+      adapter(:mysql, db) do |c, sql, params|
+        statement = c.prepare(sql)
+        begin
+          statement.execute(*params)&.to_a || []
+        ensure
+          statement.close
+        end
+      end
+    end
+
+    # sqlite3 gem: a SQLite3::Database, or a ConnectionPool of them.
+    def self.sqlite3(db)
+      adapter(:sqlite, db) do |c, sql, params|
+        statement = c.prepare(sql)
+        begin
+          statement.execute(*params).map { |row| row.is_a?(Hash) ? row : statement.columns.zip(row).to_h }
+        ensure
+          statement.close
+        end
+      end
+    end
+
+    # A pool (anything with +with+, like the connection_pool gem) lends a connection per statement; a single
+    # connection is used by one thread at a time.
+    def self.adapter(dialect, db, &run)
+      lock = Mutex.new
+      new(dialect) do |sql, params|
+        db.respond_to?(:with) ? db.with { |c| run.call(c, sql, params) } : lock.synchronize { run.call(db, sql, params) }
+      end
+    end
+    private_class_method :adapter
+  end
+
+  # A table on PostgreSQL, MySQL or SQLite through a SqlExecutor. Column names are the model's field names
+  # (quoted, so case sensitive on PostgreSQL); every value is a bound parameter; LIKE escapes with
+  # <tt>ESCAPE '!'</tt>, which every database reads the same way. Without a sort, rows come back by primary key
+  # ascending. +auto_create+ creates a missing SQLite table: create production tables yourself.
+  class SqlRepository < Repository
+    QUOTES = { sqlite: %w[" "], postgres: %w[" "], mysql: %w[` `] }.freeze
+    OPS = { "EQ" => "=", "NEQ" => "<>", "GT" => ">", "GTE" => ">=", "LT" => "<", "LTE" => "<=" }.freeze
+    SQLITE_TYPES = { EditType::NUMBER => "NUMERIC", EditType::BOOLEAN => "INTEGER", EditType::DATE => "DATE",
+                     DATE_TIME => "TIMESTAMP", EditType::REFERENCE_TABLE => "INTEGER",
+                     EditType::REFERENCE_TREE => "INTEGER" }.freeze
+
+    # Collects bound values and writes the dialect's placeholder for each.
+    class Params
+      attr_reader :values
+
+      def initialize(dialect)
+        @dialect, @values = dialect, []
+      end
+
+      def <<(value)
+        @values << bindable(value)
+        @dialect == :postgres ? "$#{@values.size}" : "?"
+      end
+
+      private
+
+      def bindable(value)
+        case value
+        when true, false then @dialect == :postgres ? value : (value ? 1 : 0)
+        when Time, DateTime then value.strftime("%Y-%m-%d %H:%M:%S.%L")
+        when Date then value.strftime("%Y-%m-%d")
+        else value
+        end
+      end
+    end
+
+    def initialize(executor, table, auto_create: false)
+      super()
+      raise ArgumentError, "illegal table name '#{table}'" unless IDENTIFIER.match?(table.to_s)
+      raise ArgumentError, "auto_create creates SQLite tables only" if auto_create && executor.dialect != :sqlite
+
+      @executor, @table, @auto_create = executor, table.to_s, auto_create
+      @dialect = executor.dialect
+    end
+
+    def bind(model)
+      super
+      @columns = model.fields.keys.to_h { |name| [name.downcase, name] }
+      return unless @auto_create
+
+      cols = model.fields.each_value.map do |f|
+        f.pk? ? "#{q(f.name)} INTEGER PRIMARY KEY AUTOINCREMENT" : "#{q(f.name)} #{SQLITE_TYPES.fetch(f.type, "TEXT")}"
+      end
+      @executor.call("CREATE TABLE IF NOT EXISTS #{q(@table)} (#{cols.join(", ")})", [])
+    end
+
+    def page(query)
+      p = Params.new(@dialect)
+      total = @executor.call("SELECT COUNT(*) AS n FROM #{q(@table)}#{where(query, p)}", p.values).first
+      p = Params.new(@dialect)
+      sql = "SELECT * FROM #{q(@table)}#{where(query, p)}"
+      order = (query.sort.empty? ? [[model.pk, false]] : query.sort).map { |name, desc| "#{q(name)} #{desc ? "DESC" : "ASC"}" }
+      sql += " ORDER BY #{order.join(", ")} LIMIT #{p << query.limit} OFFSET #{p << query.offset}"
+      [Integer(total.values.first.to_s, 10), @executor.call(sql, p.values).map { |row| record(row) }]
+    end
+
+    def get(pk)
+      p = Params.new(@dialect)
+      row = @executor.call("SELECT * FROM #{q(@table)} WHERE #{q(model.pk)} = #{p << pk}", p.values).first
+      row && record(row)
+    end
+
+    def add(record)
+      record = store(record)
+      p = Params.new(@dialect)
+      values = record.values.map { |v| p << v }
+      @executor.call("INSERT INTO #{q(@table)} (#{record.keys.map { |k| q(k) }.join(", ")}) VALUES (#{values.join(", ")})", p.values)
+    end
+
+    def update(pk, record)
+      record = store(record)
+      return if record.empty?
+
+      p = Params.new(@dialect)
+      sets = record.map { |k, v| "#{q(k)} = #{p << v}" }
+      @executor.call("UPDATE #{q(@table)} SET #{sets.join(", ")} WHERE #{q(model.pk)} = #{p << pk}", p.values)
+    end
+
+    def delete(pks)
+      return if pks.empty?
+
+      p = Params.new(@dialect)
+      marks = pks.map { |pk| p << pk }
+      @executor.call("DELETE FROM #{q(@table)} WHERE #{q(model.pk)} IN (#{marks.join(", ")})", p.values)
+    end
+
+    # A quoted identifier; the closing quote is doubled.
+    def q(identifier)
+      open, close = QUOTES.fetch(@dialect)
+      "#{open}#{identifier.gsub(close, close * 2)}#{close}"
+    end
+
+    private
+
+    # Values as columns hold them: a JSON value as its text
+    def store(record)
+      keys(record).except(model.pk).to_h { |k, v| [k, model.fields[k]&.json? && !v.nil? ? JSON.generate(v) : v] }
+    end
+
+    def where(query, p)
+      clauses = query.filters.map do |sql, params|
+        # the developer's own SQL, as written; with params, each '?' is one of them, bound like every other value
+        pieces = params.empty? ? [sql] : sql.split("?", -1)
+        raise ArgumentError, "filter: #{pieces.size - 1} '?' for #{params.size} params in #{sql.inspect}" if pieces.size - 1 != params.size
+
+        "(#{pieces.first}#{params.zip(pieces.drop(1)).map { |v, piece| (p << v) + piece }.join})"
+      end
+      clauses += query.conditions.map do |c|
+        col = q(c.field)
+        values = Array(c.value)
+        case c.op
+        when *OPS.keys then "#{col} #{OPS[c.op]} #{p << c.value}"
+        when "LIKE", "NOT_LIKE"
+          # '!' rather than a backslash: MySQL reads a backslash inside a string literal as an escape itself;
+          # ILIKE because PostgreSQL's LIKE is case sensitive, the others' (and the memory repository's) is not
+          pattern = "%#{c.value.to_s.gsub(/[!%_]/) { |ch| "!#{ch}" }}%"
+          "#{col} #{"NOT " if c.op == "NOT_LIKE"}#{@dialect == :postgres ? "ILIKE" : "LIKE"} #{p << pattern} ESCAPE '!'"
+        when "RANGE" then "#{col} BETWEEN #{p << values[0]} AND #{p << values[1]}"
+        when "IN", "NOT_IN"
+          next(c.op == "IN" ? "1=0" : "1=1") if values.empty?
+
+          "#{col} #{"NOT " if c.op == "NOT_IN"}IN (#{values.map { |v| p << v }.join(", ")})"
+        when "NULL" then "#{col} IS NULL"
+        when "NOT_NULL" then "#{col} IS NOT NULL"
+        else raise ArgumentError, "illegal operator '#{c.op}'"
+        end
+      end
+      clauses.empty? ? "" : " WHERE #{clauses.join(" AND ")}"
+    end
+
+    # A driver row as a record: columns matched to fields case-insensitively, values normalized by field type
+    # (pg returns text, mysql2 Time / BigDecimal, sqlite3 what was stored).
+    def record(row)
+      row = row.to_h { |k, v| [@columns.fetch(k.to_s.downcase, k.to_s), v] }
+      model.fields.each_value.to_h do |f|
+        value = row[f.name]
+        [f.name, value.nil? ? nil : normalize(f, value)]
+      end
+    end
+
+    def normalize(field, value)
+      return value.is_a?(String) ? JSON.parse(value) : value if field.json?
+
+      case field.type
+      when EditType::BOOLEAN then [true, 1, "1", "t", "true"].include?(value)
+      when EditType::DATE then Erupt.parse_time(value).to_date
+      when DATE_TIME then Erupt.parse_time(value)
+      when EditType::NUMBER, *REFERENCES then Erupt.number(value)
+      else field.pk? ? Erupt.number(value) : value
+      end
+    end
+  end
+end

data/lib/erupt/types.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+# Generated by tools/gen_types.rb from erupt-annotations.schema.json; do not edit.
+module Erupt
+  # Values of +AttachmentTypeType+: +BASE+ instead of the string "BASE".
+  module AttachmentTypeType
+    BASE = "BASE"
+    IMAGE = "IMAGE"
+  end
+
+  # Values of +BoolTypeType+: +AUTO+ instead of the string "AUTO".
+  module BoolTypeType
+    AUTO = "AUTO"
+    RADIO = "RADIO"
+    SWITCH = "SWITCH"
+  end
+
+  # Values of +CalendarViewMode+: +MONTH+ instead of the string "MONTH".
+  module CalendarViewMode
+    MONTH = "MONTH"
+    WEEK = "WEEK"
+    YEAR = "YEAR"
+  end
+
+  # Values of +CalloutTypeStyle+: +CARD+ instead of the string "CARD".
+  module CalloutTypeStyle
+    CARD = "CARD"
+    INFO = "INFO"
+    SUCCESS = "SUCCESS"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+  end
+
+  # Values of +CardViewCoverEffect+: +FIT+ instead of the string "FIT".
+  module CardViewCoverEffect
+    FIT = "FIT"
+    CLIP = "CLIP"
+  end
+
+  # Values of +ChoiceTypeType+: +SELECT+ instead of the string "SELECT".
+  module ChoiceTypeType
+    SELECT = "SELECT"
+    RADIO = "RADIO"
+  end
+
+  # Values of +CubeChartType+: +LINE+ instead of the string "LINE".
+  module CubeChartType
+    LINE = "LINE"
+    AREA = "AREA"
+    BAR = "BAR"
+    COLUMN = "COLUMN"
+    PIE = "PIE"
+    SCATTER = "SCATTER"
+    RADAR = "RADAR"
+    FUNNEL = "FUNNEL"
+    DUAL_AXES = "DUAL_AXES"
+    GAUGE = "GAUGE"
+    WATERFALL = "WATERFALL"
+    WORD_CLOUD = "WORD_CLOUD"
+    ROSE = "ROSE"
+    RADIAL_BAR = "RADIAL_BAR"
+    SANKEY = "SANKEY"
+    CHORD = "CHORD"
+    MAP = "MAP"
+    BUBBLE = "BUBBLE"
+    TREEMAP = "TREEMAP"
+    HEATMAP = "HEATMAP"
+    TINY_LINE = "TINY_LINE"
+    TINY_AREA = "TINY_AREA"
+    TINY_COLUMN = "TINY_COLUMN"
+    PROGRESS = "PROGRESS"
+    RING_PROGRESS = "RING_PROGRESS"
+    TABLE = "TABLE"
+    PIVOT_TABLE = "PIVOT_TABLE"
+    KPI = "KPI"
+  end
+
+  # Values of +DateTypePickerMode+: +ALL+ instead of the string "ALL".
+  module DateTypePickerMode
+    ALL = "ALL"
+    FUTURE = "FUTURE"
+    HISTORY = "HISTORY"
+  end
+
+  # Values of +DateTypeType+: +AUTO+ instead of the string "AUTO".
+  module DateTypeType
+    AUTO = "AUTO"
+    DATE = "DATE"
+    TIME = "TIME"
+    DATE_TIME = "DATE_TIME"
+    MONTH = "MONTH"
+    WEEK = "WEEK"
+    QUARTER = "QUARTER"
+    YEAR = "YEAR"
+  end
+
+  # Values of +DynamicCtrl+: +SHOW+ instead of the string "SHOW".
+  module DynamicCtrl
+    SHOW = "SHOW"
+    HIDE = "HIDE"
+    NOTNULL = "NOTNULL"
+    READONLY = "READONLY"
+  end
+
+  # Values of +EditType+: +AUTO+ instead of the string "AUTO".
+  module EditType
+    AUTO = "AUTO"
+    INPUT = "INPUT"
+    PASSWORD = "PASSWORD"
+    NUMBER = "NUMBER"
+    SLIDER = "SLIDER"
+    COLOR = "COLOR"
+    ICON = "ICON"
+    KEY_VALUE = "KEY_VALUE"
+    RATE = "RATE"
+    DATE = "DATE"
+    BOOLEAN = "BOOLEAN"
+    CHOICE = "CHOICE"
+    MULTI_CHOICE = "MULTI_CHOICE"
+    TAGS = "TAGS"
+    AUTO_COMPLETE = "AUTO_COMPLETE"
+    TEXTAREA = "TEXTAREA"
+    HTML_EDITOR = "HTML_EDITOR"
+    CODE_EDITOR = "CODE_EDITOR"
+    MARKDOWN = "MARKDOWN"
+    ATTACHMENT = "ATTACHMENT"
+    MAP = "MAP"
+    TPL = "TPL"
+    DIVIDE = "DIVIDE"
+    GROUP = "GROUP"
+    CALLOUT = "CALLOUT"
+    BUTTON = "BUTTON"
+    HIDDEN = "HIDDEN"
+    EMPTY = "EMPTY"
+    SIGNATURE = "SIGNATURE"
+    REFERENCE_TREE = "REFERENCE_TREE"
+    REFERENCE_TABLE = "REFERENCE_TABLE"
+    CHECKBOX = "CHECKBOX"
+    TRANSFER = "TRANSFER"
+    TAB_TREE = "TAB_TREE"
+    TAB_TABLE_REFER = "TAB_TABLE_REFER"
+    TAB_TABLE_ADD = "TAB_TABLE_ADD"
+    MULTI_FORM = "MULTI_FORM"
+    COMBINE = "COMBINE"
+  end
+
+  # Values of +HtmlEditorTypeType+: +CKEDITOR+ instead of the string "CKEDITOR".
+  module HtmlEditorTypeType
+    CKEDITOR = "CKEDITOR"
+    UEDITOR = "UEDITOR"
+  end
+
+  # Values of +LayoutFormSize+: +DEFAULT+ instead of the string "DEFAULT".
+  module LayoutFormSize
+    DEFAULT = "DEFAULT"
+    FULL_LINE = "FULL_LINE"
+  end
+
+  # Values of +LayoutPagingType+: +BACKEND+ instead of the string "BACKEND".
+  module LayoutPagingType
+    BACKEND = "BACKEND"
+    FRONT = "FRONT"
+    NONE = "NONE"
+  end
+
+  # Values of +MultiChoiceTypeType+: +SELECT+ instead of the string "SELECT".
+  module MultiChoiceTypeType
+    SELECT = "SELECT"
+    CHECKBOX = "CHECKBOX"
+    TRANSFER = "TRANSFER"
+  end
+
+  # Values of +OpenWay+: +DRAWER+ instead of the string "DRAWER".
+  module OpenWay
+    DRAWER = "DRAWER"
+    MODAL = "MODAL"
+    ROUTER = "ROUTER"
+  end
+
+  # Values of +PageEmbedType+: +IFRAME+ instead of the string "IFRAME".
+  module PageEmbedType
+    IFRAME = "IFRAME"
+    MICRO_FRONTEND = "MICRO_FRONTEND"
+  end
+
+  # Values of +Placement+: +TOP+ instead of the string "TOP".
+  module Placement
+    TOP = "TOP"
+    BOTTOM = "BOTTOM"
+    LEFT = "LEFT"
+    RIGHT = "RIGHT"
+  end
+
+  # Values of +QueryExpression+: +AUTO+ instead of the string "AUTO".
+  module QueryExpression
+    AUTO = "AUTO"
+    EQ = "EQ"
+    NEQ = "NEQ"
+    GT = "GT"
+    GTE = "GTE"
+    LT = "LT"
+    LTE = "LTE"
+    LIKE = "LIKE"
+    NOT_LIKE = "NOT_LIKE"
+    RANGE = "RANGE"
+    IN = "IN"
+    NOT_IN = "NOT_IN"
+    NULL = "NULL"
+    NOT_NULL = "NOT_NULL"
+  end
+
+  # Values of +RowOperationIfExprBehavior+: +HIDE+ instead of the string "HIDE".
+  module RowOperationIfExprBehavior
+    HIDE = "HIDE"
+    DISABLE = "DISABLE"
+  end
+
+  # Values of +RowOperationMode+: +SINGLE+ instead of the string "SINGLE".
+  module RowOperationMode
+    SINGLE = "SINGLE"
+    MULTI = "MULTI"
+    MULTI_ONLY = "MULTI_ONLY"
+    BUTTON = "BUTTON"
+  end
+
+  # Values of +RowOperationType+: +ERUPT+ instead of the string "ERUPT".
+  module RowOperationType
+    ERUPT = "ERUPT"
+    TPL = "TPL"
+  end
+
+  # Values of +TimelineViewMode+: +LEFT+ instead of the string "LEFT".
+  module TimelineViewMode
+    LEFT = "LEFT"
+    ALTERNATE = "ALTERNATE"
+    RIGHT = "RIGHT"
+  end
+
+  # Values of +ViewStatistic+: +NONE+ instead of the string "NONE".
+  module ViewStatistic
+    NONE = "NONE"
+    COUNT = "COUNT"
+    DISTINCT_COUNT = "DISTINCT_COUNT"
+    SUM = "SUM"
+    AVG = "AVG"
+    MAX = "MAX"
+    MIN = "MIN"
+  end
+
+  # Values of +ViewType+: +AUTO+ instead of the string "AUTO".
+  module ViewType
+    AUTO = "AUTO"
+    TEXT = "TEXT"
+    COLOR = "COLOR"
+    ICON = "ICON"
+    KEY_VALUE = "KEY_VALUE"
+    SAFE_TEXT = "SAFE_TEXT"
+    IMAGE = "IMAGE"
+    AVATAR = "AVATAR"
+    IMAGE_BASE64 = "IMAGE_BASE64"
+    SWF = "SWF"
+    HTML = "HTML"
+    MOBILE_HTML = "MOBILE_HTML"
+    QR_CODE = "QR_CODE"
+    LINK = "LINK"
+    LINK_DIALOG = "LINK_DIALOG"
+    DOWNLOAD = "DOWNLOAD"
+    ATTACHMENT = "ATTACHMENT"
+    ATTACHMENT_DIALOG = "ATTACHMENT_DIALOG"
+    DATE = "DATE"
+    DATE_TIME = "DATE_TIME"
+    BOOLEAN = "BOOLEAN"
+    NUMBER = "NUMBER"
+    PROGRESS = "PROGRESS"
+    MAP = "MAP"
+    CODE = "CODE"
+    TAB_VIEW = "TAB_VIEW"
+    MARKDOWN = "MARKDOWN"
+    PASSWORD = "PASSWORD"
+  end
+
+  # Values of +VisFieldVisibility+: +INCLUDE+ instead of the string "INCLUDE".
+  module VisFieldVisibility
+    INCLUDE = "INCLUDE"
+    EXCLUDE = "EXCLUDE"
+  end
+
+  # Values of +VisType+: +TABLE+ instead of the string "TABLE".
+  module VisType
+    TABLE = "TABLE"
+    GANTT = "GANTT"
+    CARD = "CARD"
+    BOARD = "BOARD"
+    CALENDAR = "CALENDAR"
+    TIMELINE = "TIMELINE"
+    MAP = "MAP"
+    CUBE = "CUBE"
+    TPL = "TPL"
+  end
+end

data/lib/erupt/version.rb

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

data/lib/erupt-sdk.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Lets Bundler auto-require the gem by its name.
+require_relative "erupt"

data/lib/erupt.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Erupt node SDK: give any Ruby service an erupt admin UI through an erupt cloud server.
+require_relative "erupt/version"
+require_relative "erupt/types"
+require_relative "erupt/schema"
+require_relative "erupt/signature"
+require_relative "erupt/model"
+require_relative "erupt/repository"
+require_relative "erupt/sql"
+require_relative "erupt/http_server"
+require_relative "erupt/node"