svix 1.64.1 → 1.65.0

data/templates/summary.rb.jinja

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-# This file is @generated
-
-require "json"
-require "openssl"
-require "base64"
-require "uri"
-require "logger"
-
-{% macro require_api(resource) -%}
-require "svix/api/{{ resource.name | to_snake_case }}"
-{% endmacro -%}
-
-
-# API
-{% for resource in api.resources -%}
-{{ require_api(resource) -}}
-    {% for _resource_name, resource in resource.subresources | items -%}
-{{ require_api(resource) -}}
-    {% endfor -%}
-{% endfor -%}
-
-# Models
-{% for type in types -%}
-require "svix/models/{{ type | to_snake_case }}"
-{% endfor -%}
-
-# Core
-require "svix/api_error"
-require "svix/errors"
-require "svix/svix"
-require "svix/util"
-require "svix/version"
-require "svix/webhook"
-require "svix/http_error_out"
-require "svix/http_validation_error"
-require "svix/validation_error"
-require "svix/svix_http_client.rb"
-require "svix/internal"

data/templates/types/integer_enum.rb.jinja

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-# This file is @generated
-{% set class_ty = type.name | to_upper_camel_case  -%}
-
-module Svix
-  {% if type.description is defined -%}
-  {{ type.description | to_doc_comment(style="ruby") | indent(4) }}
-  {% endif -%}
-  class {{ class_ty }}
-    {% for name, value in type.variants -%}
-    {{ name | to_upper_snake_case }} = {{ value }}.freeze
-    {% endfor %}
-    def self.all_vars
-      @all_vars ||= [
-        {%- for name, value in type.variants -%}
-        {{ name | to_upper_snake_case }},
-        {%- endfor -%}
-      ].freeze
-    end
-
-    def initialize(value)
-      unless {{ class_ty }}.all_vars.include?(value)
-        raise "Invalid ENUM value '#{value}' for class #{{ class_ty }}"
-      end
-      @value = value
-    end
-
-    def self.deserialize(value)
-      return value if {{ class_ty }}.all_vars.include?(value)
-      raise "Invalid ENUM value '#{value}' for class #{{ class_ty }}"
-    end
-
-    def serialize
-      @value
-    end
-  end
-end

data/templates/types/macros.rb.jinja

@@ -1,43 +0,0 @@
-{% macro deserialize_field(field) -%}
-    {% set val_expr %}attributes['{{ field.name }}']{% endset -%}
-    {% set not_nil_check = "" -%}
-    {% if not field.required -%}
-        {% set not_nil_check %}if {{ val_expr }}{% endset -%}
-    {% endif -%}
-
-    {% if (field.type.is_set() or  field.type.is_list()) and field.type.inner_type().is_schema_ref() -%}
-        {% set val_expr -%}
-            attributes['{{ field.name }}'].map { | v | Svix::{{ field.type.inner_type().to_ruby() }}.deserialize v } {{ not_nil_check }}
-        {%- endset -%}
-    {% elif field.type.is_schema_ref() -%}
-        {# TODO(10055): the schema called "Data" does not exist -#}
-        {% if field.type.to_ruby() != "Data" -%}
-            {% set val_expr -%}
-            Svix::{{ field.type.to_ruby() }}.deserialize(attributes['{{ field.name }}']) {{ not_nil_check }}
-            {%- endset -%}
-        {% endif -%}
-    {% elif field.type.is_datetime() -%}
-        {% set val_expr %}DateTime.rfc3339({{ val_expr }}).to_time {{ not_nil_check }}{% endset -%}
-    {% endif -%}
-    attrs['{{ field.name | to_snake_case }}'] = {{ val_expr }}
-{% endmacro -%}
-
-{% macro serialize_field(field) -%}
-    {% set val_expr %}@{{ field.name | to_snake_case }}{% endset -%}
-
-    {% if (field.type.is_set() or  field.type.is_list()) and field.type.inner_type().is_schema_ref() -%}
-        {% set val_expr %}{{ val_expr }}.map { | v | v.serialize }{% endset -%}
-    {% elif field.type.is_schema_ref() -%}
-        {# TODO(10055): the schema called "Data" does not exist -#}
-        {% if field.type.to_ruby() != "Data" -%}
-            {% set val_expr %}Svix::serialize_schema_ref({{ val_expr }}){% endset -%}
-        {% endif -%}
-    {% else -%}
-        {% set val_expr %}Svix::serialize_primitive({{ val_expr }}){% endset -%}
-    {% endif -%}
-    {% if type.name is endingwith "Patch" and field.nullable -%}
-    out['{{ field.name }}'] = {{ val_expr }} if @__{{ field.name | to_snake_case }}_is_defined
-    {% else -%}
-    out['{{ field.name }}'] = {{ val_expr }} if @{{ field.name | to_snake_case }}
-    {% endif -%}
-{% endmacro -%}

data/templates/types/string_enum.rb.jinja

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-# This file is @generated
-{% set class_ty = type.name | to_upper_camel_case  -%}
-
-module Svix
-  {% if type.description is defined -%}
-  {{ type.description | to_doc_comment(style="ruby") | indent(4) }}
-  {% endif -%}
-  class {{ class_ty }}
-    {% for value in type.values -%}
-    {{ value | to_upper_snake_case }} = "{{ value }}".freeze
-    {% endfor %}
-    def self.all_vars
-      @all_vars ||= [
-        {%- for value in type.values -%}
-        {{ value | to_upper_snake_case }},
-        {%- endfor -%}
-      ].freeze
-    end
-
-    def initialize(value)
-      unless {{ class_ty }}.all_vars.include?(value)
-        raise "Invalid ENUM value '#{value}' for class #{{ class_ty }}"
-      end
-      @value = value
-    end
-
-    def self.deserialize(value)
-      return value if {{ class_ty }}.all_vars.include?(value)
-      raise "Invalid ENUM value '#{value}' for class #{{ class_ty }}"
-    end
-
-    def serialize
-      @value
-    end
-  end
-end

data/templates/types/struct.rb.jinja

@@ -1,58 +0,0 @@
-{% from "types/macros.rb.jinja" import deserialize_field, serialize_field -%}
-{% set class_ty = type.name | to_upper_camel_case  -%}
-# frozen_string_literal: true
-# This file is @generated
-require 'json'
-
-module Svix
-  {% if type.description is defined -%}
-  {{ type.description | to_doc_comment(style="ruby") | indent(4) }}
-  {% endif -%}
-  class {{ class_ty }}
-    {% for field in type.fields -%}
-    attr_accessor :{{ field.name | to_snake_case }}
-    {% endfor %}
-    ALL_FIELD ||= [
-      {%- for f in type.fields -%}
-      "{{ f.name | to_snake_case }}"{% if not loop.last %},{% endif %}
-      {%- endfor -%}
-    ].freeze
-    private_constant :ALL_FIELD
-
-    def initialize(attributes = {})
-      unless attributes.is_a?(Hash)
-        fail ArgumentError, "The input argument (attributes) must be a hash in `Svix::{{ class_ty }}` new method"
-      end
-      attributes.each do |k, v|
-        unless ALL_FIELD.include? k.to_s
-          fail ArgumentError, "The field #{k} is not part of Svix::{{ class_ty }}"
-        end
-        instance_variable_set("@#{k}", v)
-        instance_variable_set("@__#{k}_is_defined", true)
-      end
-    end
-
-    def self.deserialize(attributes = {})
-      attributes = attributes.transform_keys(&:to_s)
-      attrs = Hash.new
-      {% for field in type.fields -%}
-        {{ deserialize_field(field) -}}
-      {% endfor -%}
-      new attrs
-    end
-
-    def serialize
-      out = Hash.new
-      {% for field in type.fields -%}
-        {{ serialize_field(field) -}}
-      {% endfor -%}
-      out
-    end
-
-    # Serializes the object to a json string
-    # @return String
-    def to_json
-      JSON.dump(serialize)
-    end
-  end
-end

data/templates/types/struct_enum.rb.jinja

@@ -1,116 +0,0 @@
-{% from "types/macros.rb.jinja" import deserialize_field, serialize_field -%}
-{% set class_ty = type.name | to_upper_camel_case  -%}
-{% set enum_type_name %}{{ class_ty }}{{ type.content_field | to_upper_camel_case }}{% endset-%}
-# frozen_string_literal: true
-# This file is @generated
-require 'json'
-
-{% for r in referenced_components -%}
-require_relative "./{{ r | to_snake_case }}"
-{% endfor %}
-
-module Svix
-  class {{ enum_type_name }}
-    {% for v in type.variants -%}
-    class {{ v.name | to_upper_camel_case }} {%- if v.schema_ref is defined -%}< {{ v.schema_ref | to_upper_camel_case}}{%- endif %}
-      {% if not v.schema_ref is defined %}
-      def serialize
-        Hash.new
-      end
-      def self.deserialize(attributes = {})
-        new()
-      end
-      # Serializes the object to a json string
-      # @return String
-      def to_json
-        JSON.dump(serialize)
-      end
-      {% endif -%}
-    end
-    {% endfor -%}
-  end
-
-  {% if type.description is defined -%}
-  {{ type.description | to_doc_comment(style="ruby") | indent(4) }}
-  {% endif -%}
-  class {{ class_ty }}
-    {% for field in type.fields -%}
-    attr_accessor :{{ field.name | to_snake_case }}
-    {% endfor -%}
-    attr_accessor :{{ type.content_field | to_snake_case }}
-
-    ALL_FIELD ||= [
-      {%- for f in type.fields -%}
-      "{{ f.name | to_snake_case }}",
-      {%- endfor -%}
-      "{{ type.content_field | to_snake_case }}"
-    ].freeze
-    private_constant :ALL_FIELD
-    TYPE_TO_NAME = {
-    {% for v in type.variants -%}
-      {{ enum_type_name }}::{{ v.name | to_upper_camel_case }} => "{{ v.name }}",
-    {% endfor %}
-    }
-    private_constant :TYPE_TO_NAME
-    NAME_TO_TYPE = TYPE_TO_NAME.invert
-    private_constant :NAME_TO_TYPE
-
-    def initialize(attributes = {})
-      unless attributes.is_a?(Hash)
-        fail(
-          ArgumentError,
-          "The input argument (attributes) must be a hash in `Svix::{{ class_ty }}` new method"
-        )
-      end
-      attributes.each do |k, v|
-        unless ALL_FIELD.include?(k.to_s)
-          fail(ArgumentError, "The field #{k} is not part of Svix::{{ class_ty }}")
-        end
-        if k == "{{type.content_field | to_snake_case  }}"
-          unless TYPE_TO_NAME.key?(v.class)
-            fail(ArgumentError, "The field #{k} can't be a `#{v.class}` expected one of #{TYPE_TO_NAME.keys}")
-          end
-          instance_variable_set("@__enum_discriminator", TYPE_TO_NAME[v.class])
-        end
-        instance_variable_set("@#{k}", v)
-        instance_variable_set("@__#{k}_is_defined", true)
-      end
-      if @__enum_discriminator.nil?
-        fail(ArgumentError, "Required {{ type.content_field | to_snake_case }} field was not set")
-      end
-    end
-
-    def self.deserialize(attributes = {})
-      attributes = attributes.transform_keys(&:to_s)
-      attrs = Hash.new
-      {% for f in type.fields -%}
-        {{ deserialize_field(f) -}}
-      {% endfor -%}
-      unless NAME_TO_TYPE.key?(attributes["{{ type.discriminator_field }}"])
-        fail(ArgumentError, "Invalid {{ type.discriminator_field | to_snake_case }} `#{attributes["{{ type.discriminator_field }}"]}` expected on of #{NAME_TO_TYPE.keys}")
-      end
-      unless attributes.key? "{{ type.content_field }}"
-        fail(ArgumentError, "Missing required field {{ type.content_field }}")
-      end
-      attrs["{{ type.content_field  }}"] = NAME_TO_TYPE[attributes["{{ type.discriminator_field }}"]].deserialize(attributes["{{ type.content_field }}"])
-      new(attrs)
-    end
-
-    def serialize
-      out = Hash.new
-      {% for f in type.fields -%}
-        {{ serialize_field(f) -}}
-      {% endfor -%}
-      out["{{ type.discriminator_field }}"] = @__enum_discriminator
-      out["{{ type.content_field }}"] = @{{ type.content_field | to_snake_case }}.serialize
-      out
-    end
-
-    # Serializes the object to a json string
-    # @return String
-    def to_json
-      JSON.dump(serialize)
-    end
-
-  end
-end