hamster-web 0.1.0.pre.2

data/lib/hamster/cli.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "web/version"
+require "fileutils"
+require "json"
+require "tmpdir"
+require "open3"
+require "shellwords"
+require_relative "build/manifest"
+require_relative "build/postgres_compatibility"
+
+module Hamster
+  module CLI
+    def self.run(arguments)
+      args = arguments.dup
+      command = args.shift
+      case command
+      when "--version"
+        puts Web::VERSION
+        0
+      when "new"
+        raise ArgumentError, "Usage: hamster new AppName" unless args.length == 1
+        Generator.create(args.first)
+        0
+      when nil, "help", "--help", "-h"
+        puts "Usage: hamster new AppName | setup | manifest | manifest:check | build | serve | routes | console | db:create | db:migrate | db:validate"
+        0
+      else
+        raise ArgumentError, "Unexpected arguments: #{args.join(' ')}" unless args.empty?
+        dispatch(command)
+      end
+    rescue StandardError, Gem::LoadError => error
+      warn error.message
+      1
+    end
+
+    def self.root
+      path = Dir.pwd
+      loop do
+        return path if File.file?(File.join(path, "config/hamster.json"))
+        parent = File.dirname(path)
+        raise "No Hamster application found" if parent == path
+        path = parent
+      end
+    end
+
+    def self.dispatch(command)
+      app_root = root
+      metadata = JSON.parse(File.read(File.join(app_root, "config/hamster.json")))
+      binary = ENV.fetch("HAMSTER_SERVER_BINARY", File.join(app_root, "bin", "#{metadata.fetch('name')}-server"))
+      case command
+      when "console", "c", "db:validate"
+        adapter = File.join(app_root, "config/commands.rb")
+        raise "Missing config/commands.rb; add the command adapter from the current app template" unless File.file?(adapter)
+        require adapter
+        if command == "db:validate"
+          require_relative "schema_validation"
+          issues = SchemaValidation.run(ApplicationCommands.database)
+          raise issues.join("\n") unless issues.empty?
+          puts "Database declarations validated (#{Table.registry.length} tables); no migrations were run."
+        else
+          require_relative "console"
+          Console.run(ApplicationCommands.build)
+        end
+      when "setup"
+        Dir.chdir(app_root) { raise "Dependency installation failed" unless system("bundle", "install") }
+        Dir.chdir(app_root) { raise "Spin dependency vendoring failed" unless system("spin", "vendor") } if File.file?(File.join(app_root, "spin.toml"))
+        Build::PostgresCompatibility.apply(app_root) if File.file?(File.join(app_root, "spin.toml"))
+      when "db:create", "db:migrate"
+        output, status = Open3.capture2e("spin", "list", "--json", chdir: app_root)
+        raise "Cannot resolve PostgreSQL dependency: #{output}" unless status.success?
+        pg = JSON.parse(output).find { |package| package["name"] == "pg" }
+        raise "PostgreSQL dependency missing; configure pg in spin.toml and run setup" unless pg
+        driver = File.join(app_root, "vendor/packages", "pg-#{pg.fetch('version')}")
+        raise "PostgreSQL dependency not vendored; run bin/hamster setup" unless File.file?(File.join(driver, "pg/client.rb"))
+        $LOAD_PATH.unshift(driver)
+        require_relative "database/postgres"
+        configuration = Hamster::Database::Configuration.from_env(app_name: metadata.fetch("name"))
+        if command == "db:create"
+          created = Hamster::Database::Admin.create!(configuration)
+          puts(created ? "Database created: #{configuration.database}" : "Database already exists: #{configuration.database}")
+        else
+          database = Hamster::Database.new(configuration, migrations_path: File.join(app_root, "db/migrations"))
+          begin
+            database.migrate!
+            puts "Database migrated: #{configuration.database}"
+          ensure
+            database.shutdown
+          end
+        end
+      when "manifest"
+        Build::Manifest.generate(app_root)
+      when "manifest:check"
+        issues = Build::Manifest.check(app_root)
+        raise issues.join("\n") unless issues.empty?
+        puts "Manifest check passed"
+      when "build"
+        Build::PostgresCompatibility.apply(app_root) if File.file?(File.join(app_root, "spin.toml"))
+        Build::Manifest.generate(app_root)
+        issues = Build::Manifest.check(app_root)
+        raise issues.join("\n") unless issues.empty?
+        spinner = Gem::Specification.find_by_name("spinel-spinner").full_gem_path
+        temporary = binary + ".tmp"
+        begin
+          Dir.chdir(app_root) do
+            flags = ["--require-gate", "-I", File.expand_path("..", __dir__), "-I", File.join(spinner, "lib"), "-I", "."]
+            if File.file?("spin.toml")
+              output, diagnostic, status = Open3.capture3("spin", "flags")
+              raise "Spin dependency resolution failed: #{diagnostic}" unless status.success?
+              flags.concat(Shellwords.split(output))
+            end
+            raise "Spinel compilation failed" unless system(ENV.fetch("SPINEL", "spinel"), "bin/server", *flags, "-o", temporary)
+          end
+          File.rename(temporary, binary)
+        ensure
+          File.delete(temporary) if File.file?(temporary)
+        end
+        puts "Built #{binary}"
+      when "serve", "server", "s"
+        raise "Server binary missing; run bin/hamster build" unless File.executable?(binary)
+        Dir.chdir(app_root) { exec(binary) }
+      when "routes"
+        require File.join(app_root, "config/application")
+        Hamster::View.route_mapping.routes.each do |route|
+          puts [route.method, route.pattern, route.name, route.action.name].join("  ")
+        end
+      else
+        raise ArgumentError, "Unknown command: #{command}"
+      end
+      0
+    end
+  end
+
+  module Generator
+    def self.create(input)
+      unless input.match?(/\A(?:[A-Z][A-Za-z0-9]*|[a-z][a-z0-9]*(?:_[a-z0-9]+)*)\z/)
+        raise ArgumentError, "Use a PascalCase or snake_case application name"
+      end
+      name = input.gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2').gsub(/([a-z0-9])([A-Z])/, '\\1_\\2').downcase
+      namespace = name.split("_").map(&:capitalize).join
+      raise ArgumentError, "Reserved application name" if %w[Hamster Spinner Object Kernel BasicObject Class Module].include?(namespace)
+      destination = File.expand_path(name)
+      raise ArgumentError, "Destination already exists: #{destination}" if File.exist?(destination) || File.symlink?(destination)
+      template = File.expand_path("../../templates/app", __dir__)
+      Dir.mktmpdir(".hamster-", File.dirname(destination)) do |container|
+        staging = File.join(container, "app")
+        FileUtils.mkdir_p(staging)
+        Dir.glob("**/*", File::FNM_DOTMATCH, base: template).each do |relative|
+          next if [".", ".."].include?(File.basename(relative))
+          source = File.join(template, relative)
+          target = File.join(staging, relative)
+          if File.directory?(source)
+            FileUtils.mkdir_p(target)
+          else
+            File.write(target, File.read(source).gsub("__APP_MODULE__", namespace).gsub("__APP_NAME__", name).gsub("__HAMSTER_VERSION__", Web::VERSION))
+          end
+        end
+        Build::Manifest.generate(staging)
+        File.chmod(0755, File.join(staging, "bin/hamster"))
+        raise "Destination appeared during generation" if File.exist?(destination)
+        File.rename(staging, destination)
+      end
+      puts "Created #{name}. Next: cd #{name} && bin/hamster setup"
+    end
+  end
+end

data/lib/hamster/console.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hamster
+  module Console
+    def self.run(application)
+      app = application
+      database = application.database
+      puts "Hamster console (app, application, database)"
+      if database
+        database.with_connection do |connection|
+          workspace = binding
+          if block_given?
+            yield workspace
+          else
+            start(workspace)
+          end
+        end
+      elsif block_given?
+        yield binding
+      else
+        start(binding)
+      end
+    ensure
+      application.shutdown
+    end
+
+    def self.start(workspace)
+      require "irb"
+      IRB.setup(__FILE__, argv: [])
+      IRB::Irb.new(IRB::WorkSpace.new(workspace)).run(IRB.conf)
+    end
+    private_class_method :start
+  end
+end

data/lib/hamster/data/persistence.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Hamster
+  module Persistence
+    include Record
+
+    module ClassMethods
+      include Record
+
+      def connection
+        Record.connection
+      end
+
+      def write_table_name
+        if schema_name == "public" && table_name.match?(/\A[a-z_][a-z0-9_]*\z/)
+          table_name
+        else
+          %Q("#{schema_name.gsub('"', '""')}"."#{table_name.gsub('"', '""')}")
+        end
+      end
+
+      def create_fields
+        columns.select { |_name, definition| [:create, :both].include?(definition[:write]) }.keys.map(&:to_s)
+      end
+
+      def update_fields
+        columns.select { |_name, definition| [:update, :both].include?(definition[:write]) }.keys.map(&:to_s)
+      end
+
+      def create(**attributes)
+        Instrumentation.record(name, "create") { persist_create(**attributes) }
+      end
+
+      # Shared persistence path; the caller owns the record boundary.
+      def persist_create(**attributes)
+        check_fields!(attributes, create_fields)
+        record = new(**attributes)
+        errors = validate_create(attributes)
+        return Result.new(record: record, code: :invalid, errors: errors) unless errors.empty?
+
+        now = Time.now.utc.iso8601
+        timestamps = %w[created_at updated_at].select { |name| self.columns.key?(name.to_sym) }
+        columns = create_fields + timestamps
+        values = create_fields.map { |name| attributes[name.to_sym] } + timestamps.map { now }
+        placeholders = (1..columns.length).map { |number| "$#{number}" }.join(", ")
+        sql = "INSERT INTO #{write_table_name} (#{columns.join(', ')}) VALUES (#{placeholders}) " \
+              "RETURNING #{(['id'] + timestamps).join(', ')}"
+        row = connection.execute(sql, values).hashes.first
+        return Result.new(record: record, code: :database_error, errors: ["Could not save record."]) unless row
+
+        record.id = row["id"]
+        record.write_attribute(:created_at, row["created_at"]) if self.columns.key?(:created_at)
+        record.write_attribute(:updated_at, row["updated_at"]) if self.columns.key?(:updated_at)
+        Result.new(record: record)
+      rescue Hamster::Database::Error => error
+        database_failure(record, error)
+      end
+      private :persist_create
+
+      def create!(**attributes)
+        create(**attributes).value!
+      end
+
+      def validate_create(_attributes)
+        []
+      end
+
+      def check_fields!(attributes, allowed)
+        unknown = attributes.keys.map(&:to_s) - allowed
+        raise ArgumentError, "Undeclared record fields: #{unknown.join(', ')}" unless unknown.empty?
+      end
+
+      def database_failure(record, error)
+        if error.is_a?(Hamster::Database::QueryError) && error.sqlstate == "23505"
+          Result.new(record: record, code: :conflict, errors: ["Record already exists."], cause: error)
+        else
+          Result.new(record: record, code: :database_error, errors: ["Could not save record."], cause: error)
+        end
+      end
+    end
+
+    def update(**changes)
+      Instrumentation.record(self.class.name, "update") do
+        self.class.check_fields!(changes, self.class.update_fields)
+        next missing_result if id.nil? || destroyed?
+        next Result.new(record: self, code: :invalid, errors: ["No changes supplied."]) if changes.empty?
+
+        errors = validate_update(changes)
+        next Result.new(record: self, code: :invalid, errors: errors) unless errors.empty?
+
+        now = Time.now.utc.iso8601
+        columns = self.class.update_fields.select { |name| changes.key?(name.to_sym) }
+        values = columns.map { |name| changes[name.to_sym] }
+        timestamps = self.class.columns.key?(:updated_at)
+        columns << "updated_at" if timestamps
+        values << now if timestamps
+        assignments = columns.each_with_index.map { |name, index| "#{name} = $#{index + 1}" }.join(", ")
+        returning = timestamps ? "updated_at" : "id"
+        sql = "UPDATE #{self.class.write_table_name} SET #{assignments} WHERE id = $#{values.length + 1} RETURNING #{returning}"
+        row = self.class.connection.execute(sql, values + [id]).hashes.first
+        next missing_result unless row
+
+        apply_changes(changes)
+        write_attribute(:updated_at, row["updated_at"]) if timestamps
+        Result.new(record: self)
+      rescue Hamster::Database::Error => error
+        self.class.database_failure(self, error)
+      end
+    end
+
+    def update!(**changes)
+      update(**changes).value!
+    end
+
+    def destroy
+      Instrumentation.record(self.class.name, "destroy") do
+        next missing_result if id.nil? || destroyed?
+
+        sql = "DELETE FROM #{self.class.write_table_name} WHERE id = $1 RETURNING id"
+        row = self.class.connection.execute(sql, [id]).hashes.first
+        next missing_result unless row
+
+        @destroyed = true
+        Result.new(record: self)
+      rescue Hamster::Database::Error => error
+        self.class.database_failure(self, error)
+      end
+    end
+
+    def destroy!
+      destroy.value!
+    end
+
+    def destroyed?
+      @destroyed == true
+    end
+
+    def validate_update(_changes)
+      []
+    end
+
+    def apply_changes(changes)
+      changes.each { |name, value| write_attribute(name, value) }
+    end
+
+    private
+
+    def missing_result
+      Result.new(record: self, code: :not_found, errors: ["Record not found."])
+    end
+  end
+end

data/lib/hamster/data/query.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Hamster
+  # Named read-only projections; all execution remains in Relation.
+  class Query < KeyedRow
+    REGISTRY = []
+
+    def self.inherited(child)
+      child.set_definition(@base_source, fields, clauses)
+      REGISTRY << child
+    end
+
+    def self.registry
+      REGISTRY.dup.freeze
+    end
+
+    def self.validate_all!
+      registry.each { |query| query.all.compile }
+    end
+
+    def self.set_definition(source, definitions, operations)
+      @base_source = source
+      @fields = definitions.dup
+      @local_fields = []
+      @clauses = operations.dup
+    end
+
+    def self.fields
+      Read.snapshot(@fields || {})
+    end
+
+    def self.clauses
+      Read.snapshot(@clauses || [])
+    end
+
+    def self.from(source)
+      @base_source = source.all.source
+    end
+
+    def self.field(name, source:)
+      register_field(name, source)
+      # Spinel cannot expand a macro with a nonliteral source: expression.
+      # The manifest emits the equivalent static getters for compilation.
+      define_method("#{name}") { self[name] } if RUBY_ENGINE == "ruby"
+    end
+
+    def self.register_field(name, source)
+      key = Read.identifier(name).to_sym
+      unless key.to_s.match?(/\A[a-z_][a-z0-9_]*\z/)
+        raise Read::ValidationError, "#{self.name}: SELECT: field #{key} cannot be used as a result accessor"
+      end
+      if Query.method_defined?(key) || Query.private_method_defined?(key)
+        raise Read::ValidationError, "#{self.name}: SELECT: field #{key} would shadow a result method"
+      end
+      @local_fields ||= []
+      if @local_fields.include?(key)
+        raise Read::ValidationError, "#{self.name}: SELECT: duplicate field #{key}"
+      end
+      unless source.is_a?(Read::Node)
+        raise Read::ValidationError, "#{self.name}: SELECT: field #{key} source must be a SQL expression"
+      end
+      @local_fields = @local_fields + [key]
+      @fields = fields.merge(key => source)
+    end
+
+    def self.output(name); SQL.output(name); end
+
+    def self.add_clause(kind, args)
+      @clauses = clauses + [Read.snapshot([kind, args])]
+    end
+
+    def self.joins(source, on:); add_clause(:joins, [source, on]); end
+    def self.left_joins(source, on:); add_clause(:left_joins, [source, on]); end
+    def self.where(condition); add_clause(:where, [condition]); end
+    def self.group(*items); add_clause(:group, items); end
+    def self.having(condition); add_clause(:having, [condition]); end
+    def self.order(*items); add_clause(:order, items); end
+    def self.reorder(*items); add_clause(:reorder, items); end
+    def self.distinct(enabled = true); add_clause(:distinct, [enabled]); end
+    def self.limit(value); add_clause(:limit, [value]); end
+    def self.offset(value); add_clause(:offset, [value]); end
+
+    def self.all
+      raise Read::ValidationError, "#{name}: FROM: declare a base source with from" unless @base_source
+      raise Read::ValidationError, "#{name}: SELECT: declare at least one field" if fields.empty?
+      projection = fields.map { |key, expression| expression.as(key) }
+      relation = Relation.new(@base_source, { identity: name, select: projection, explicit: true,
+                                            result_class: self, declared_fields: projection })
+      clauses.each do |kind, args|
+        relation = case kind
+                   when :joins then relation.joins(args[0], on: args[1])
+                   when :left_joins then relation.left_joins(args[0], on: args[1])
+                   when :where then relation.where(args[0])
+                   when :group then relation.group(*args)
+                   when :having then relation.having(args[0])
+                   when :order then relation.order(*args)
+                   when :reorder then relation.reorder(*args)
+                   when :distinct then relation.distinct(args[0])
+                   when :limit then relation.limit(args[0])
+                   when :offset then relation.offset(args[0])
+                   end
+      end
+      relation
+    end
+  end
+end

data/lib/hamster/data/read/compiler.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Hamster
+  module Read
+    class Compiled
+      attr_reader :sql, :binds, :dependencies, :outputs, :row_class, :table_rows, :result_class
+      def initialize(sql, binds, validated, count: false)
+        @sql = sql.freeze
+        @binds = Read.snapshot(binds)
+        @dependencies = validated.dependencies
+        @outputs = count ? Read.snapshot([{ name: "count", type: :bigint, nullable: false }]) : validated.outputs
+        @row_class = validated.source.row_class
+        @result_class = count ? nil : validated.result_class
+        @table_rows = count ? false : validated.table_rows
+        freeze
+      end
+    end
+
+    class Compiler
+      def initialize(validated)
+        @validated = validated
+        @binds = []
+      end
+
+      def compile(count: false)
+        state = @validated.state
+        sql = state[:distinct] ? "SELECT DISTINCT " : "SELECT "
+        sql += state[:select].map { |node| expression(node) }.join(", ")
+        sql += " FROM #{source_sql(@validated.source)}"
+        state[:joins].each do |join|
+          kind = join.options[:kind] == :left ? "LEFT JOIN" : "INNER JOIN"
+          sql += " #{kind} #{source_sql(join.args[0])} ON #{expression(join.args[1])}"
+        end
+        sql += " WHERE " + state[:where].map { |node| expression(node) }.join(" AND ") unless state[:where].empty?
+        sql += " GROUP BY " + state[:group].map { |node| expression(node) }.join(", ") unless state[:group].empty?
+        sql += " HAVING " + state[:having].map { |node| expression(node) }.join(" AND ") unless state[:having].empty?
+        unless state[:order].empty?
+          sql += " ORDER BY " + state[:order].map { |node| "#{expression(node.args[0])} #{node.args[1].to_s.upcase}" }.join(", ")
+        end
+        sql += " LIMIT #{bind(state[:limit])}" unless state[:limit].nil?
+        sql += " OFFSET #{bind(state[:offset])}" unless state[:offset].nil?
+        sql = "SELECT COUNT(*) AS count FROM (#{sql}) AS hamster_count" if count
+        Compiled.new(sql, @binds, @validated, count: count)
+      end
+
+      def quote(name)
+        '"' + name.to_s.gsub('"', '""') + '"'
+      end
+
+      def source_sql(source)
+        "#{quote(source.schema)}.#{quote(source.name)} AS #{quote(source.label)}"
+      end
+
+      def bind(value)
+        @binds << value
+        "$#{@binds.length}"
+      end
+
+      def expression(node)
+        case node.kind
+        when :column then "#{quote(node.args[0].label)}.#{quote(node.args[1])}"
+        when :value then bind(node.args[0])
+        when :as then "#{expression(node.args[0])} AS #{quote(node.args[1])}"
+        when :count
+          inner = node.args.empty? ? "*" : expression(node.args[0])
+          "COUNT(#{node.options[:distinct] ? 'DISTINCT ' : ''}#{inner})"
+        when :raw
+          "(" + node.args.map { |part| part.is_a?(String) ? part : bind(part.args[0]) }.join + ")"
+        when :and, :or
+          "(#{expression(node.args[0])} #{node.kind.to_s.upcase} #{expression(node.args[1])})"
+        when :not then "(NOT #{expression(node.args[0])})"
+        when :eq, :not_eq, :gt, :gte, :lt, :lte
+          left = expression(node.args[0])
+          right = node.args[1]
+          if right.kind == :value && right.args[0].nil?
+            "(#{left} IS #{node.kind == :not_eq ? 'NOT ' : ''}NULL)"
+          else
+            operator = { eq: "=", not_eq: "<>", gt: ">", gte: ">=", lt: "<", lte: "<=" }[node.kind]
+            "(#{left} #{operator} #{expression(right)})"
+          end
+        when :ilike
+          "(#{expression(node.args[0])} ILIKE #{expression(node.args[1])})"
+        when :in, :not_in
+          values = node.args[1]
+          return node.kind == :in ? "FALSE" : "TRUE" if values.empty?
+          non_null = values.reject { |value| value.nil? }
+          negative = node.kind == :not_in
+          pieces = []
+          unless non_null.empty?
+            left = expression(node.args[0])
+            pieces << "#{left} #{negative ? 'NOT IN' : 'IN'} (#{non_null.map { |value| bind(value) }.join(', ')})"
+          end
+          pieces << "#{expression(node.args[0])} IS #{negative ? 'NOT ' : ''}NULL" if values.include?(nil)
+          "(" + pieces.join(negative ? " AND " : " OR ") + ")"
+        else
+          raise ValidationError, "Unsupported compiled expression #{node.kind}"
+        end
+      end
+    end
+  end
+end

data/lib/hamster/data/read/decoder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Hamster
+  class KeyedRow
+    def initialize(attributes)
+      @attributes = Read.snapshot(attributes)
+      freeze
+    end
+
+    def [](name)
+      fetch(name)
+    end
+
+    def fetch(name)
+      key = name.to_sym
+      raise MissingAttributeError, "Unloaded attribute #{key}" unless @attributes.key?(key)
+      @attributes[key]
+    end
+
+    def to_h
+      @attributes.dup
+    end
+  end
+
+  module Read
+    class Decoder
+      def initialize(compiled)
+        @compiled = compiled
+      end
+
+      def decode(result)
+        expected = @compiled.outputs.map { |out| out[:name] }
+        unless result.columns == expected && result.columns.uniq.length == result.columns.length
+          raise DecodeError, "Result columns do not match the projection"
+        end
+        types = @compiled.outputs.map { |out| TYPES[out[:type]] }
+        raise DecodeError, "Result PostgreSQL type IDs do not match the projection" unless result.types == types
+        row_class = @compiled.row_class
+        result.rows.map do |cells|
+          raise DecodeError, "Result row width does not match the projection" unless cells.length == expected.length
+          attributes = {}
+          @compiled.outputs.each_with_index do |out, index|
+            attributes[out[:name].to_sym] = cell(cells[index], out)
+          end
+          if @compiled.result_class
+            @compiled.result_class.new(attributes)
+          elsif @compiled.table_rows
+            row_class.new(attributes)
+          else
+            KeyedRow.new(attributes)
+          end
+        end
+      end
+
+      def cell(value, output)
+        if value.nil?
+          raise DecodeError, "Unexpected NULL for #{output[:name]}" unless output[:nullable]
+          return nil
+        end
+        raise DecodeError, "Expected raw text cell for #{output[:name]}" unless value.is_a?(String)
+        case output[:type]
+        when :text then value.dup
+        when :integer, :bigint
+          raise DecodeError, "Malformed integer for #{output[:name]}" unless value.match?(/\A-?[0-9]+\z/)
+          begin
+            number = value.to_i
+          rescue RangeError
+            raise DecodeError, "Integer out of range for #{output[:name]}"
+          end
+          low, high = output[:type] == :integer ? [-2147483648, 2147483647] : [-9223372036854775808, 9223372036854775807]
+          raise DecodeError, "Integer out of range for #{output[:name]}" unless number >= low && number <= high
+          number
+        when :boolean
+          return true if value == "t"
+          return false if value == "f"
+          raise DecodeError, "Malformed boolean for #{output[:name]}"
+        when :timestamptz
+          # PostgreSQL ISO DateStyle uses a space and may emit an hour-only offset.
+          unless value.match?(/\A[0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?[+-][0-9]{2}(:[0-9]{2})?\z/)
+            raise DecodeError, "Malformed timestamp for #{output[:name]}"
+          end
+          normalized = value.sub(" ", "T")
+          normalized += ":00" if normalized.match?(/[+-][0-9]{2}\z/)
+          begin
+            timestamp = Time.iso8601(normalized)
+            unless timestamp.strftime("%Y-%m-%dT%H:%M:%S") == normalized[0, 19]
+              raise DecodeError, "Malformed timestamp for #{output[:name]}"
+            end
+            timestamp
+          rescue ArgumentError
+            raise DecodeError, "Malformed timestamp for #{output[:name]}"
+          end
+        else
+          raise DecodeError, "Unsupported output type"
+        end
+      end
+    end
+  end
+end