Forem: Hideaki Ishii

Create a sample app with TypeScript, React, typeorm, type-graphql. graphql-code-generator while reading "Learning GraphQL"

Hideaki Ishii — Sun, 24 Jan 2021 04:59:11 +0000

Recently, I was reading a book Learning GraphQL to learn GraphQL.
To understand it deeply, I tried to create a sample app: https://github.com/danimal141/learning-graphql-ts

It's not interesting to just copy a sample app written in the book, so I used TypeScript, typeorm, type-graphql, graphql-code-generator.
I'm happy if this post is helpful for someone who tries to create the same application.

Common

The book uses JavaScript but I used TypeScript.
- GraphQL itself has a type system, so I think TypeScript and GraphQL are compatible.
Adopted a Monorepo directory structure.
- Used yarn workspace to put all packages together.
Used npm-run-all to enable to run commands for the front-end and back-end at once.
Used lint-staged and husky to run Prettier when committing.
Add ESLint etc.
Sorry for skipping tests...

back-end

Used typeorm and type-graphql to define the GraphQL schema and DB schema conveniently.
- type-graphql automatically generates the schema file :)
- It might be better o try Nest.js...?

front-end

Used create-react-app to create a TypeScript based project.
- Created only the user list view and login feature.
- The React way in the book seemed a bit old so I used React hooks actively.
Used graphql-code-generator to generate the types for TypeScript from the GraphQL schema that the back-end generated.
Child components defines only GraphQL fragments and Root component should construct the whole query as much as possible (Fragment colocation).
Login feature was a bit hard for me because it's my first time to use Mutation...
- The book uses Mutation component、but I used React hooks instead.

Conclusion

GraphQL is awesome.
TypeScript and GraphQL are compatible.
typeorm seems good for back-end developments.

References

What is a good code review?

Hideaki Ishii — Sat, 14 Nov 2020 13:46:43 +0000

I've put together a list of points like what is important I think in code review.

Purpose of Code Review

To ensure the quality of your product
- People basically make mistakes
- Two heads are better than one
To share knowledge with the team
- Sharing knowledge of the code with the team at all times avoids the problem of personalization, e.g., "Only A-san knows this feature, I don't know...".
- It's a great opportunity where you can read other member's code and ask questions if any.
To share responsibility within the team
- When something goes wrong, only the person who wrote the relevant code should never be blamed.
- It's the responsibility of the team not to notice the problem at the time of review (or until the code is deployed), so we should fix problems as a team.

Reviewer edition

Points to keep in mind when reviewing

What should you review in PR?
Does the code meet the Acceptance Criteria for the relevant Issue?
- It's necessary for reviewers to check the behavior as well in your local if the code affects the UI.
Is the code design OK?
- Is it extensible?
- Can you update the code easily when some specification changes?
- If it's a disposable part, you would be able to refactor it later, but if it's a core part of the product (such as DB design), it's better to review the design carefully.
- Are responsibilities for classes and methods properly separated? (Single Responsibility Principle)
- Is the implementation easy to test?
  - Hard to write tests -> In many cases, the responsibilities of the class or method are wrong/bad.
  - The code may include too many dependencies or may try to do too many things.
  - If you see a method name like a_and_b, it obviously means to do more than one thing, and it can be often isolated the methods.
- Is dependency OK?
- Model depends on View, etc.
- Is error handling well?
- Doesn't the code return a server error when it's clearly a client error in the API.
- Can you understand/solve the problem from the error information? (traceable?)
Are the tests enough?
Are there any bugs?
Are existent features still working well? (Some feature is not broken?)
Does deploy the code cause downtime?
- If yes, is the deployment flow proposed properly?
Are there any security risks?
Does the coding style follow the rules within the team?
- Basically, it's better to automate it like "check by Lint -> fail in CI if something is needed to fix it" instead of discussing it in a review.

Mindset

You should assume that you are going to maintain the code later on.
- If you think, "This is going to be tough to maintain," you should do your best to improve the quality for your future self by review.
Let's review it in terms of "how would you design it if you were to implement it?".
- Comparing your design to theirs will help you enhance your design skills and would lead to more constructive discussions.
If you feel some implementation isn't good, you should point out the code, not the person.
- When pointing something out, let's always give reasons why you think it's not good.
- If it turns out your point is incorrect, you should apologize honestly, and please appreciate the reviewee for discussing it.
Let's ask questions about the parts you don't understand.
- The reviewee can notice mistakes from the questions, and even if there are no problems, both can learn, and the reviewee can feel confident in their implementation.
Let's answer questions from the reviewee sincerely.
- Your review sometimes may confuse the reviewee due to the knowledge gap, in that case providing sample code or sharing links to articles may be helpful.
If the discussion is going to be difficult on a PR (e.g. there are so many comments in a PR and discussion is still going on), it might be better to suggest having a meeting or pair programming or something like that.
It's better not to push your preferences too far.
- If it's a matter of preference, you can basically respect the reviewee's approach.
- If you wanna share your preference, it's good to use tags like FYI, IMO, nits, etc to inform the point is not serious.
- If it's about coding style, it might be a good idea to suggest if the team can reconsider the lint rules and coding conventions.
Let's actively praise what you think is good
- Reviews are often mainly about pointing out things, so if you think it's good and you learn something through the review, let's praise the reviewee's code and design.
- This kind of communication often makes for a better team atmosphere (I guess).

Reviewee edition

Points to keep in mind when being reviewed.

Do you specify what you want people to review in your PR?
- Acceptance criteria
- Is the PR scope clear?
- What has been implemented in the PR?
- What is not implemented in the PR?
  - If you are leaving a TODO, do you create a separate issue for it?
Does the code meet the Acceptance Criteria for the relevant Issue?
- Always self-review before requesting a review, so that the reviewer doesn't have to review so many points.
Is the volume of the PR appropriate?
- Huge PRs make it difficult for reviewers to notice problems when reviewing, so let's avoid them as much as possible.
- Can we split up the PR and request a review?
- For example, if the PR is large and includes a library update, it looks like it can be split into a PR for the library update and a PR to resolve the actual issue.
Is the implementation simple?
- Is the code you wrote still understandable to anyone, including you, a few months later?
Did you leave supplementary comments in the code or PR if some implementation may not be able to understand your intentions in the code alone?

Mindset

You should be able to answer any questions about your implementation.
- If you refer to something, share the reference link as well.
- Official documentation is better than someone's blog post.
Let's ask questions if you don't understand a reviewer's point.
- let's follow the reviewer's points after you are convinced them (don't follow without understanding/considering)
The reviewer's point of view is beneficial to you.
- Pointing things out in a review is a great opportunity to learn how others think better, and you may notice your mistakes and it would lead to your growth.
- You may sometimes feel disappointed when you are pointed out, let's be strong and overcome :)

The difference between Mocks, Stubs, and Spies

Hideaki Ishii — Sun, 06 Sep 2020 03:23:03 +0000

This post describes the difference between Mocks, Stubs, and Spies, and I use RSpec to show examples.

I hope this helps you write excellent tests!

TL;DR

In this great article, Mr. Martin Fowler says:

Stubs provide canned answers to calls made during the test, usually not responding at all to anything outside what's programmed in for the test.

Spies are stubs that also record some information based on how they were called. One form of this might be an email service that records how many messages it was sent.

Mocks are what we are talking about here: objects pre-programmed with expectations which form a specification of the calls they are expected to receive.

See the difference with RSpec

Stubs

For example, if some method depends on a third-party API, it's not good to request it whenever testing.
In that case, stubs are very useful.

class SomeClient
  def request
    body = some_lib.request
    JSON.parse body
  end

  private

  def some_lib
    @some_lib ||= SomeLib.new
  end
end

describe 'SomeClient#request'
  before do
    allow(client).to receive(:some_lib).with(no_args).and_return(some_lib)
    allow(some_lib).to receive(:request).with(no_args).and_return(expected_boby)
  end

  let(:client) { SomeClient.new }
  let(:some_lib) { instance_double(SomeLib) }
  let(:expected_body) { ... }
  let(:expected_json) { JSON.parse expected_body }

  subject { client.request }

  it { is_expected.to eq expected_json }
end

We can avoid calling the API actually by stubs.

Mocks

In the above stub example, if the client actually calls the API many times, it's completely unexpected.

If we want to ensure whether the some_lib method is invoked expectedly, using mocks is more suitable.

describe 'SomeClient#request'
  before { allow(client).to receive(:some_lib).with(no_args).and_return(some_lib)  }

  let(:client) { SomeClient.new }
  let(:some_lib) { instance_double(SomeLib) }
  let(:expected_body) { ... }
  let(:expected_json) { JSON.parse expected_body }

  subject { client.request }

  it do
    expect(some_lib).to receive(:request).with(no_args).and_return(expected_boby).once # Ensure it's really called expectedly.
    is_expected.to eq expected_json
  end

If SomeLib#request is called unexpectedly (wrong args, called many times, etc.), the test will fail.

Spies

In rspec-mocks, though it's a bit difficult to clarify the difference between mocks and spies...

RSpec documentation says:

Message expectations put an example's expectation at the start, before you've invoked the code-under-test. Many developers prefer using an arrange-act-assert (or given-when-then) pattern for structuring tests. Spies are an alternate type of test double that support this pattern by allowing you to expect that a message has been received after the fact, using have_received.

The above example would become with spies like:

describe 'SomeClient#request'
  before { allow(client).to receive(:some_lib).with(no_args).and_return(some_lib)  }

  let(:client) { SomeClient.new }
  let(:some_lib) { instance_spy(SomeLib) } # It's OK to use `instance_double` instead, I describe the difference afterward.
  let(:expected_body) { ... }
  let(:expected_json) { JSON.parse expected_body }

  subject { client.request }

  it do
    is_expected.to eq expected_json
    expect(some_lib).to have_received(:request).with(no_args).and_return(expected_boby).once
  end
end

It might be more intuitive.

After subject is called, the test checks whether SomeLib#request is really called expectedly.

instance_spy(SomeLib) is similar to instance_double(SomeLib). The difference is:

instance_double
- Can stub methods.
- If you try to stub the undefined method, it would raise an error.
instance_spy
- Mix stubs and real objects.
- If some real method is not stubbed, the real one would be called.

Summary

Let's clarify the difference and write excellent tests!

Reference

How to connect your DB with an SSH Tunnel and Docker

Hideaki Ishii — Sat, 05 Sep 2020 06:48:08 +0000

When using a database like PostgreSQL, we usually use a managed database like Amazon RDS nowadays.

Then we would configure to allow only some servers to connect to the database (e.g. only EC2 servers can connect to a database on RDS).

But sometimes, we want to connect to such a database and check something from our local. In that case, we can use an SSH tunnel way.

This post describes how to do that.

Docker image

To connect to your database, you have to execute a command like psql, mysql, or something like that.
So let's prepare a Docker image which is compatible with your actual database.

In this post, I plan to use PostgreSQL as an example, but there is no PostgreSQL specific information. Please select your favorite one.

SSH tunnel

Let's try to create an SSH tunnel next!

The actual command would be like this:

$ ssh -L 15432:db.some-service.jp:5432 web.some-service.jp -N

To do that, you have to be able to ssh web.some-service.jp, if your SSH tunneling failed, please try ssh -i {your_ssh_key} {your_ssh_user}@web.some-service.jp or make sure your ssh config is correct.

The above command means forwarding your local's 15432 port to db.some-service.jp's 5432 port.

By specifying -N option, the command does not execute a remote command. This is useful for just forwarding ports.

Don't close this command and let's try to actually connect to your database in the next step!

Connect to your database

Please open a new tab and let's try to connect to your database.

The actual command would be like this:

$ docker run -it --rm postgres:11.9 psql -h host.docker.internal -p 15432 -U db-user -W db_name

# Enter your db password
Password:
db_name=> SELECT * from users;
...

You can connect to the special DNS name host.docker.internal which resolves to the internal IP address used by the host.

And then by specifying 15432 which is forwarded in the previous step, you can connect to your database and execute commands there!

At last, don't forget to close your forwarding command!

Summary

Using an SSH tunnel and Docker, we can connect to our remote database easily.

References

https://docs.docker.com/docker-for-mac/networking/#use-cases-and-workarounds

Keep your code format clean using prettier

Hideaki Ishii — Sat, 31 Aug 2019 09:08:33 +0000

I recently used prettier to keep my team's code format clean, then I felt it worked well.

This post introduces how to use prettier in a team.

What kind of project do we start?

As an example, let's think about a situation we will create a git repository and write a lot of markdown documentation, and anyone can contribute to the repository.

We surely want to keep the code format clean and consistent.

Install `prettier`

Following this documentation, we can install prettier.

In this post, I use yarn to install it.
All we have to do is executing yarn add prettier --dev --exact in the project root.

After that, we would get package.json and yarn.lock.

How to use `prettier`

To try to use prettier, Let's update package.json like:

{
  "scripts": {
    "prettier": "prettier *.md --write"
  },
  "devDependencies": {
    "prettier": "xxx"
  }
}

And please prepare a dirty sample markdown like:

$ touch test.md

# Test

## testtest

This is a test!

- test1
- test2

Then let's invoke yarn prettier.
After that, the sample file's format would become clean like:

# Test

## testtest

This is a test!

- test1
- test2

In this post, I will use the default configuration, but if you would like to configure, please refer to this documentation.

Use `prettier` on CI to validate the code format

Currently, to keep the code format clean, everyone has to always execute yarn prettier while modifying files. I feel it's very easy to forget.

To notice some format is unexpected soon, let's use CI.

At first, to check the code format, we can use prettier --check. Let's add another command to package.json.

{
  "scripts": {
    "prettier": "prettier *.md --write",
    "lint:prettier": "prettier --check *.md"
  },
  "devDependencies": {
    "prettier": "xxx"
  }
}

To review the code each other, we basically use GitHub or something like that. Then we can invoke the validation command in every pull request via CI like CircleCI.

This is sample CircleCI configuration:

$ mkdir -p .circleci & touch .circleci/config.yml

version: 2.1
jobs:
  build:
    docker:
      - image: circleci/node:10
    working_directory: ~/repo

    steps:
      - checkout
      - restore_cache:
          keys:
            - v1-dependencies-{{ checksum "yarn.lock" }}
            - v1-dependencies-

      - run: yarn install

      - save_cache:
          paths:
            - node_modules
          key: v1-dependencies-{{ checksum "yarn.lock" }}

      - run:
          name: Prettier
          command: yarn lint:prettier

After integrating GitHub and CircleCI, we can ensure the code format (if some format is unexpected, the CI fails).

To contribute to the project, yarn prettier is a must for everyone.

Summary

prettier is very convenient and easy to use.
Using prettier on CI, we would be able to keep our code clean more robustly.

References

Create an SFTP server with AWS Transfer for SFTP

Hideaki Ishii — Sun, 07 Jul 2019 09:58:26 +0000

This post describes how to create an SFTP server on AWS (AWS Transfer for SFTP).
About the overview of AWS Transfer for SFTP, please refer to here.

Decide SFTP Configuration

AWS SFTP can configure:

DNS configuration
- "None" or "Amazon Route53 DNS alias"
Identity provider
- "Service Managed" or "Custom"
Logging role
Tags

In this post, I decided to configure like:

DNS configuration
- "None" (Use an endpoint name which AWS creates directly)
Identity provider
- "Service Managed" (Use the AWS SFTP feature)

Logging role and Tags are not used in this post.

Prepare S3 bucket for SFTP server

AWS SFTP requires an S3 bucket, so let's prepare your bucket first.

In this post, I prepared a bucket named danimal141-sftp-test, which has a folder named test as an example.

Create CloudFormation template

To achieve creating an SFTP server, we should do:

Create an IAM policy
Create an IAM role
Create an SFTP server
Create an SFTP user
- It has the above IAM role

There are many dependencies, so let's use AWS CloudFormation to make the process easier.
The template becomes like this:



AWSTemplateFormatVersion: '2010-09-09'

Resources:
  SftpAccessPolicy:
    Type: AWS::IAM::ManagedPolicy
    Properties:
      ManagedPolicyName: SftpAccessPolicy
      Description: Sftp access policy
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Action:
              - 's3:PutObject'
              - 's3:GetObject'
              - 's3:DeleteObject'
              - 's3:GetObjectVersion'
              - 's3:DeleteObjectVersion'
            Resource: 'arn:aws:s3:::danimal141-sftp-test/test/*'
          - Effect: Allow
            Action:
              - 's3:ListBucket'
              - 's3:GetBucketLocation'
            Resource: 'arn:aws:s3:::danimal141-sftp-test'
            Condition:
              StringLike:
                's3:prefix': 'test/*'

  SftpAccessRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: 'Allow'
            Principal:
              Service:
                - 'transfer.amazonaws.com'
            Action:
              - 'sts:AssumeRole'
      ManagedPolicyArns:
        - !Ref SftpAccessPolicy

  SftpServer:
    Type: AWS::Transfer::Server
    Properties:
      EndpointType: PUBLIC

  SftpUser:
    Type: AWS::Transfer::User
    Properties:
      UserName: testuser
      HomeDirectory: '/danimal141-sftp-test/test'
      Role: !GetAtt SftpAccessRole.Arn
      ServerId: !GetAtt SftpServer.ServerId
      SshPublicKeys:
        - YOUR PUBLIC KEY

About IAM policies and roles for SFTP, you could refer to here.

Create CloudFormation stack

Let's create a CloudFormation stack with the above template on the AWS console or aws cloudformation command.

The important point is that the process requires capabilities: [AWS::IAM::ManagedPolicy, AWS::IAM::Role].
We should acknowledge that CloudFormation might create IAM resources with custom names.

After finishing creating the stack successfully, you would be able to see the SFTP server on the AWS console!
And then, you can check the server with sftp command like:



sftp -i your_ssh_key your_user_name@server_endpoint

sftp> pwd
Remote working directory: /danimal141-sftp/test

sftp> put index.html
Uploading index.html to /danimal141-sftp-test/test/index.html

sftp> rm index.html
Removing /danimal141-sftp-test/test/index.html

sftp> exit

Of course, you could also use an app like Cyberduck or something like that.

Clean up dependencies

Please be careful of forgetting removing the SFTP server, because you are billed on an hourly basis from the time you create and configure your SFTP server, which is provisioned for your dedicated use, until the time you delete the server (Reference: here).

If you use CloudFormation like the above example, it's dead easy to clean up all dependencies.
All you have to do is just deleting the CloudFormation stack!

Summary

We can create an SFTP server easily with AWS Transfer for SFTP.
We can create and delete stuff related to the SFTP server easily with AWS CloudFormation.

References

How to investigate memory usage on ElastiCache for Redis

Hideaki Ishii — Sat, 15 Jun 2019 08:42:08 +0000

Recently, I faced a problem which memory usage on ElastiCache for Redis becomes huge.
This post describes how we can investigate such a problem (which keys are bottlenecks on ElastiCache).

Export and download a Redis backup

At first, to analyze, we have to download the .rdb file from our ElastiCache following the official guide.

When exporting an ElastiCache backup, please be careful that the region for S3 must be the same as the one for the backup.

Analyze `.rdb` with redis-rdb-tools

After downloading the file, we can analyze it with redis-rdb-tools.

For example, if we wanna generate a memory report, we can do it as follows.

> rdb -c memory /var/redis/6379/dump.rdb --bytes 128 -f memory.csv
> cat memory.csv

database,type,key,size_in_bytes,encoding,num_elements,len_largest_element
0,list,lizards,241,quicklist,5,19

If your .rdb is too large (it may be difficult to open the csv file), you could also generate a sampled report like:

> rdb -c memory /var/redis/6379/dump.rdb | ruby -ne 'print $_ if rand < 0.1' > memory.csv

Of course, redis-rdb-tools supports features other than generating a memory report.
For more information, please see the README.

Summary

We can export and download a backup file easily with ElastiCache and S3.
We can analyze a .rdb file easily with a tool like redis-rdb-tools.

References

Flattening a nested hash to a single hash in Ruby

Hideaki Ishii — Sun, 09 Jun 2019 13:39:53 +0000

When using Ruby, you may sometimes need to flatten a nested hash like:

{
  :foo => "bar",
  :hello => {
    :world => "Hello World",
    :bro => "What's up dude?",
  },
  :a => { :b => { :c => "d" } }
}

to a single hash like:

{
  :foo => "bar",
  :"hello.world" => "Hello World",
  :"hello.bro" => "What's up dude?",
  :"a.b.c" => "d"
}

Today, I introduce a way to achieve it referring to a post in Stack Overflow.

Let’s implement

def flatten_hash_from(hash)
  hash.each_with_object({}) do |(key, value), memo|
    next flatten_hash_from(value).each do |k, v|
      memo["#{key}.#{k}".intern] = v
    end if value.is_a? Hash
    memo[key] = value
  end
end

Using Enumberable#each_with_object recursively helps us achieve it.
Let’s deep dive into how it works.

How it works

First, key = :foo, value = "bar" is given. the value is not a hash, so memo becomes { :foo => "bar" } and the process continues.
key = :hello, value = { :world => "Hello World", :bro => "What's up dude?" } is given. The value is a hash, so flatten_hash_from is invoked again with the value.
After STEP 2, memo is {} again, which is different from the one in STEP 1. Then, key = :world, value = "Hello World" is given, which is not a hash, so memo becomes { :world => "Hello World" }. Similarly, key = :bro is given next, then memo becomes { :world => "Hello World", :bro => "What's up dude?" } and the result is returned to STEP 2.
From STEP 3, the process goes back to each part with key = :hello. By memo["#{key}.#{k}".intern] = v, memo becomes { :foo => "bar", :"hello.world" => "Hello World", :"hello.bro" => "What's up dude?" }.
Next, key = :a, value = { :b => { :c => "d" } } is given. The value is a hash then, flatten_hash_from is invoked recursively like STEP2.
flatten_hash_from is invoked with key = :b, value = { :c => "d" }.
{ :c => "d" } is returned to STEP 6.
{ :"b.c" => "d" } is returned to STEP 5.
From STEP 5, the process goes back to each part with key = :a and { :"a.b.c" => "d" } is added to memo. It turns out memo is { :foo => "bar", :"hello.world" => "Hello World", :"hello.bro" => "What's up dude?", :"a.b.c" => "d" }, then the process completed.

References

https://stackoverflow.com/questions/23521230/flattening-nested-hash-to-a-single-hash-with-ruby-rails

active_model_serializers with PORO (Plain-Old Ruby Object)

Hideaki Ishii — Sun, 09 Jun 2019 13:22:07 +0000

Recently, I worked on a Rails API project.

In the project, I fetched external data and made POROs which were compliant with active_model_serializers with the data.
Then our APIs returned the POROs serialized.

Today, I introduce the development flow a little bit.

Environment

Rails 6.0.0.beta3
active_model_serializers 0.10.9
factory_bot 5.0.2

Directory structure

app/models
- POROs
app/serializers
- Serializers
app/controllers
- Endpoints

Model

As an example, let’s consider Image model which has a URL and size information.

active_model_serializers provides ActiveModelSerializers::Model for POROs like this, which is so easy to use.

If you need to deal with a more complicated case, you would be able to implement and use a model which is compliant with this specification instead.

# app/models/image.rb
class Image < ActiveModelSerializers::Model
  attributes :url, :size
end

# app/models/image/size.rb
class Image::Size < ActiveModelSerializers::Model
  attributes :width, :height
end

Serializer

# app/serializers/image_serializer.rb
class ImageSerializer < ActiveModel::Serializer
  attributes :url, :type
  has_one :size
end

# app/serializers/image/size_serializer.rb
class Image::SizeSerializer < ActiveModel::Serializer
  attributes :width, :height
end

Defining relations like has_one, we can use include option conveniently on endpoints.

For example, render json: image, include: '*' returns JSON including size and render json: image, include: '' returns JSON without size.

Controller

We can use serializers easily in controllers. All we have to do is create a model instance and pass it to render method.

Then active_model_serializers finds a suitable serializer for an instance given and serialize it, and the response returns.

# app/controllers/v1/images_controller.rb
module V1
  class ImagesController < ApplicationController
    def show
      render json: image, include: params[:include]
    end

    private

    def image
      @image ||= Image.new(image_attrs)
    end

    def image_attrs
      @image_attrs ||= fetch_data_somehow # Fetch external data
    end
  end
end

Testing

When testing ActiveRecord models, we can use factory_bot and make the factories like:

FactoryBot.define do
  factory :user do
    name { Faker::Name.name }
  end
end

Usage:

> user = FactoryBot.create(:user)

But in this case, FactoryBot#create does not work well because there is no store (in addition, it’s not needed to store them).

Plus, ActiveModelSerializers::Model is based on ActiveModel, so the initializer requires a hash named attributes.

If we omit the argument attributes, attributes = {} will be given as the default, then serialization does not work well expectedly.

# spec/factories/images.rb
FactoryBot.define do
  factory :image do
    url { Faker::Internet.url }
    size { build(:image_size) }
  end
end

# spec/factories/image/sizes.rb
FactoryBot.define do
  factory :image_size, class: 'Image::Size' do
    width { rand(100..500) }
    height { rand(100..500) }
  end
end

Usage:

> image = FactoryBot.create(:image)
=> NoMethodError: undefined method `save!`...

> image = FactoryBot.build(:image)
> image.attributes
=> {}

> image.to_json
=> "{}"

factory_bot provides initialize_with to override initializers.

Also, it provides skip_create to skip creation.

# spec/factories/images.rb
FactoryBot.define do
  factory :image do
    skip_create
    initalize_with { new(attributes) }

    url { Faker::Internet.url }
    size { build(:image_size) }
  end
end

# spec/factories/image/sizes.rb
FactoryBot.define do
  factory :image_size, class: 'Image::Size' do
    skip_create
    initalize_with { new(attributes) }

    width { rand(100..500) }
    height { rand(100..500) }
  end
end

Usage:

> image = FactoryBot.create(:image)
=> #<Image:...> The result is the same as one from `build`🙌

> image = FactoryBot.build(:image)
> image.attributes
=> { "url" => ..., "size" => ... }

> image.to_json
=> "{\"url\":...,\"size\":...}"

To avoid writing initialize_with and skip_create many times, I eventually prepared a specific DSL like:

if defined?(FactoryBot)
  module FactoryBot
    module Syntax
      module Default
        class DSL
          # Custom DSL for ActiveModelSerializers::Model
          # Original: https://github.com/thoughtbot/factory_bot/blob/v5.0.2/lib/factory_bot/syntax/default.rb#L15-L26
          def serializers_model_factory(name, options = {}, &block)
            factory = Factory.new(name, options)
            proxy = FactoryBot::DefinitionProxy.new(factory.definition)
            if block_given?
              proxy.instance_eval do
                skip_create
                initialize_with { new(attributes) }
                instance_eval(&block)
              end
            end
            FactoryBot.register_factory(factory)

            proxy.child_factories.each do |(child_name, child_options, child_block)|
              parent_factory = child_options.delete(:parent) || name
              serializers_model_factory(child_name, child_options.merge(parent: parent_factory), &child_block)
            end
          end
        end
      end
    end
  end
end

The factory implementation turned out like:

# spec/factories/images.rb
FactoryBot.define do
  serializers_model_factory :image do
    url { Faker::Internet.url }
    size { build(:image_size) }
  end
end

Then we can use it in specs easily like:

# spec/serializers/image_serializer_spec.rb
require 'rails_helper'

RSpec.describe ImageSerializer, type: :serializer do
  let(:resource) { ActiveModelSerializers::SerializableResource.new(model, options) }
  let(:model) { build(:image) }
  let(:options) { { include: '*' } }

  describe '#url' do
    subject { resource.serializable_hash[:url] }

    it { is_expected.to eq model.url }
  end
  ...
end

Summary

We can use active_model_serializers without ActiveRecord easily.

Forem: Hideaki Ishii

Create a sample app with TypeScript, React, typeorm, type-graphql. graphql-code-generator while reading "Learning GraphQL"

Common

back-end

front-end

Conclusion

References

What is a good code review?

Purpose of Code Review

Reviewer edition

Points to keep in mind when reviewing

Mindset

Reviewee edition

Points to keep in mind when being reviewed.

Mindset

The difference between Mocks, Stubs, and Spies

TL;DR

See the difference with RSpec

Stubs

Mocks

Spies

Summary

Reference

How to connect your DB with an SSH Tunnel and Docker

Docker image

SSH tunnel

Connect to your database

Summary

References

Keep your code format clean using prettier

What kind of project do we start?

Install prettier

How to use prettier

Use prettier on CI to validate the code format

Summary

References

Create an SFTP server with AWS Transfer for SFTP

Decide SFTP Configuration

Prepare S3 bucket for SFTP server

Create CloudFormation template

Create CloudFormation stack

Clean up dependencies

Summary

References

How to investigate memory usage on ElastiCache for Redis

Export and download a Redis backup

Analyze .rdb with redis-rdb-tools

Summary

References

Flattening a nested hash to a single hash in Ruby

Let’s implement

How it works

References

active_model_serializers with PORO (Plain-Old Ruby Object)

Environment

Directory structure

Model

Serializer

Controller

Testing

Summary

References

Install `prettier`

How to use `prettier`

Use `prettier` on CI to validate the code format

Analyze `.rdb` with redis-rdb-tools