Panko Serializers

https://panko.dev
Admin
Panko is a fast Ruby library inspired by ActiveModelSerializers 0.9 for serializing...
Tokens:4,253
Snippets:47
Trust Score:6.1
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install Panko Gem

Source: https://panko.dev/getting-started

Add the Panko serializer gem to your project's Gemfile and then run bundle install to install it.

```ruby
gem "panko_serializer"
```

```bash
bundle install
```

--------------------------------

### Create Panko Serializers

Source: https://panko.dev/getting-started

Define serializers for your models by inheriting from Panko::Serializer and specifying attributes and associations. This example shows serializers for Post and User models.

```ruby
class PostSerializer < Panko::Serializer
  attributes :title
end

class UserSerializer < Panko::Serializer
  attributes :id, :name, :age

  has_many :posts, serializer: PostSerializer
end
```

--------------------------------

### Cache and Wrap JSON with Panko JsonValue

Source: https://panko.dev/response-bag

This example shows how to serialize posts, cache the resulting JSON string, and then wrap it using Panko::JsonValue. This is useful for integrating cached JSON data seamlessly into Panko responses.

```ruby
class PostsController < ApplicationController
  def index
   posts = Cache.get("/posts")

   render json: Panko::Response.new(
     success: true,
     total_count: posts.count,
     posts: Panko::JsonValue.from(posts)
   )
  end
end
```

--------------------------------

### Simplify JSON Payload with Panko Response

Source: https://panko.dev/response-bag

This example demonstrates using Panko::Response to simplify the serialization of JSON payloads, automatically handling nested JSON strings generated by serializers. It's a more streamlined approach compared to manual JSON string nesting.

```ruby
class PostsController < ApplicationController
  def index
   posts = Post.all
   render json: Panko::Response.new(
     success: true,
     total_count: posts.count,
     posts: Panko::ArraySerializer.new(posts, each_serializer: PostSerializer)
   )
  end
end
```

--------------------------------

### Serialize Single Object with Panko Response Create

Source: https://panko.dev/response-bag

This snippet illustrates how to serialize a single object using Panko::Response.create with a block, allowing for dynamic construction of the JSON response and serialization of individual objects using a specified serializer.

```ruby
class PostsController < ApplicationController
  def show
    post = Post.find(params[:id])

    render(
      json: Panko::Response.create do |r|
        {
          success: true,
          post: r.serializer(post, PostSerializer)
        }
      end
    )
  end
end
```

--------------------------------

### Serialize Single Object with Panko

Source: https://panko.dev/getting-started

Serialize a single object using a Panko serializer. You can use `serialize_to_json` for direct JSON output or `serialize` followed by `to_json`.

```ruby
# Using Oj serializer
PostSerializer.new.serialize_to_json(Post.first)

# or, similar to #serializable_hash
PostSerializer.new.serialize(Post.first).to_json
```

--------------------------------

### Serialize JSON Payload with Panko ArraySerializer

Source: https://panko.dev/response-bag

This snippet shows how to serialize an array of posts using Panko's ArraySerializer. The output is a JSON string nested within another JSON string, which Panko::Response can handle.

```ruby
class PostsController < ApplicationController
  def index
   posts = Post.all
   render json: {
     success: true,
     total_count: posts.count,
     posts: Panko::ArraySerializer.new(posts, each_serializer: PostSerializer).to_json
   }
  end
end
```

--------------------------------

### Serialize Array of Objects in Rails Controller

Source: https://panko.dev/getting-started

Use Panko::ArraySerializer in a Rails controller to serialize a collection of objects, specifying the `each_serializer` for individual items. This example serializes a collection of users.

```ruby
class UsersController < ApplicationController
 def index
   users = User.includes(:posts).all
   render json: Panko::ArraySerializer.new(users, each_serializer: UserSerializer).to_json
 end
end
```

--------------------------------

### Defining Dynamic Filters with 'filters_for' in Ruby

Source: https://panko.dev/attributes

Demonstrates how to define dynamic filters using the `filters_for` class method. This allows for reusable filtering logic based on context and scope.

```ruby
class UserSerializer < Panko::Serializer
  attributes :id, :name, :email

  def self.filters_for(context, scope)
    {
      only: [:name]
    }
  end
end

# this line will return { 'name': '..' }
UserSerializer.serialize(User.first)
```

--------------------------------

### Applying 'only' and 'except' Filters in Ruby

Source: https://panko.dev/attributes

Illustrates how to use 'only' and 'except' filters to control which attributes are serialized. These filters help reduce data usage and improve serialization performance.

```ruby
class UserSerializer < Panko::Serializer
  attributes :id, :name, :email
end

# this line will return { 'name': '..' }
UserSerializer.new(only: [:name]).serialize(User.first)

# this line will return { 'id': '..', 'email': ... }
UserSerializer.new(except: [:name]).serialize(User.first)
```

--------------------------------

### Define Field and Method Attributes in Ruby

Source: https://panko.dev/attributes

Demonstrates how to define simple field attributes and custom method attributes for serialization. Method attributes can derive values from the serialized object.

```ruby
class UserSerializer < Panko::Serializer
  attributes :full_name

  def full_name
    "#{object.first_name} #{object.last_name}"
   end
end
```

```ruby
class PostSerializer < Panko::Serializer
  attributes :author_name

  def author_name
    "#{object.author.first_name} #{object.author.last_name}"
  end
end
```

--------------------------------

### Serialize User Object using Panko

Source: https://panko.dev/design-choices

Demonstrates the usage of a Panko serializer to serialize a User object to JSON. It shows fetching a user from the database, instantiating the serializer, and performing the serialization.

```ruby
# fetch user from database
user = User.first

# create serializer, with empty options
serializer = UserSerializer.new

# serialize to JSONserializer.serialize_to_json(user)
```

--------------------------------

### Using Aliases for Attribute Renaming in Ruby

Source: https://panko.dev/attributes

Explains how to use aliases to expose serialized attributes with different names. This method preserves Panko's type casting, unlike custom method attributes.

```ruby
class PostSerializer < Panko::Serializer
  attributes :published_at

  def published_at
    object.created_at
  end
end
```

```ruby
class PostSerializer < Panko::Serializer
  aliases created_at: :published_at
end
```

--------------------------------

### Using Context with Serializers in Ruby

Source: https://panko.dev/attributes

Shows how to pass and access context data within a Panko serializer. The context can be used to provide additional information, such as feature flags, to the serializer.

```ruby
class UserSerializer < Panko::Serializer
  attributes :id, :email

  def feature_flags
    context[:feature_flags]
  end
end

serializer = UserSerializer.new(context: {
  feature_flags: FeatureFlags.all
})

serializer.serialize(User.first)
```

--------------------------------

### Apply Nested Filters to Panko Array Serializer

Source: https://panko.dev/associations

Demonstrates how to use `Panko::ArraySerializer` with nested `only` filters to selectively serialize attributes of the main object and its associations. This allows for tailored serialization of complex data structures.

```ruby
posts = Post.all

Panko::ArraySerializer.new(posts, each_serializer: PostSerializer, only: {
  instance: [:title, :body, :author, :comments],
  author: [:id],
  comments: [:id],
})
```

--------------------------------

### Alias Association Keys in Panko Serializer

Source: https://panko.dev/associations

Shows how to use the `name` option to alias an association key in a Panko serializer. This allows the serialized output key to differ from the actual association name, providing flexibility in API design.

```ruby
class PostSerializer < Panko::Serializer
  attributes :title, :body

  has_one :actual_author, serializer: AuthorSerializer, name: :alias_author
  has_many :comments, each_serializer: CommentSerializer
end
```

--------------------------------

### Define Has-One and Has-Many Associations in Panko Serializer

Source: https://panko.dev/associations

Demonstrates how to define explicit `has_one` and `has_many` associations within a Panko serializer, specifying the serializer for each association. This allows for structured serialization of related objects.

```ruby
class PostSerializer < Panko::Serializer
  attributes :title, :body

  has_one :author, serializer: AuthorSerializer
  has_many :comments, each_serializer: CommentSerializer
end
```

--------------------------------

### Recursive Nested Filters in Panko Array Serializer

Source: https://panko.dev/associations

Explains and demonstrates recursive nested filtering in Panko, allowing selective serialization of attributes for associations of associations. This provides fine-grained control over deeply nested data.

```ruby
posts = Post.all

Panko::ArraySerializer.new(posts, only: {
  instance: [:title, :body, :author, :comments],
  author: [:id],
  comments: {
    instance: [:id, :author],
    author: [:name]
  }
})
```

--------------------------------

### Define User Serializer with Panko

Source: https://panko.dev/design-choices

Defines a Panko serializer for a User model, specifying attributes and a custom method for the 'name' field. This demonstrates how to extend Panko::Serializer to customize serialization logic.

```ruby
class UserSerializer < Panko::Serializer
  attributes :name, :age, :email

  def name
    "#{object.first_name} #{object.last_name}"
  end
end
```

--------------------------------

### Infer Serializer for Associations in Panko

Source: https://panko.dev/associations

Illustrates Panko's ability to infer the serializer for associations based on the relationship name. By default, Panko singularizes and camelizes the relationship name and looks for a corresponding serializer class.

```ruby
class PostSerializer < Panko::Serializer
  attributes :title, :body

  has_one :author
  has_many :comments
end
```
Tokens:
Raw