class Dry::Types::Schema::Key

def call_safe(input, &) = type.call_safe(input, &)

def call_unsafe(input) = type.call_unsafe(input)

def decorate?(response) = response.is_a?(Type)

def initialize(type, name, required: Undefined, **options)
  required = Undefined.default(required) do
    type.meta.fetch(:required) { !type.meta.fetch(:omittable, false) }
  end
  unless name.is_a?(::Symbol)
    raise ::ArgumentError,
          "Schemas can only contain symbol keys, #{name.inspect} given"
  end
  super
  @name = name
end

def lax = __new__(type.lax).required(false)

def maybe = __new__(type.maybe)

def meta(data = Undefined)
  if Undefined.equal?(data) || !data.key?(:omittable)
    super
  else
    self.class.warn(
      "Using meta for making schema keys is deprecated, " \
      "please use .omittable or .required(false) instead" \
      "\n" + Core::Deprecations::STACK.()
    )
    super.required(!data[:omittable])
  end
end

def omittable = required(false)

def optional = __new__(type.optional)

def required(required = Undefined)
  if Undefined.equal?(required)
    options.fetch(:required)
  else
    with(required: required)
  end
end

def required? = options.fetch(:required)

def to_ast(meta: true)
  [
    :key,
    [
      name,
      required,
      type.to_ast(meta: meta)
    ]
  ]
end

def try(input, &) = type.try(input, &)