DEV Community: Samuel Durante

How to convert a TypeScript built-in enum to a GraphQL enum

Samuel Durante — Mon, 05 Feb 2024 14:05:20 +0000

At Woovi we are GraphQL lovers, hence we develop many helpers around this tool to bring a good developer experience.

A helper that we developed is graphqlEnumBuilder, this helper allows us to convert a TypeScript built-in enum into a GraphQLEnum without difficulty. Thus, if you add a new value in your TypeScript enum, you don't need to edit your GraphQL enum, because it's generated from your TypeScript enum.

How it works

enum Gender {
  Male = 'Male',
  Female = 'Female',
}

const GenderEnumType = graphqlEnumBuilder(
  'GenderType',
  Gender,
);

When you call this GenderEnumType in some query or mutation as an argument and generate your schema file, note that the GenderEnumType is declared as an enum in the GraphQL notation.

Here is an example:

enum GenderType {
  Male
  Female
}

Code solution

import { GraphQLEnumType } from 'graphql';

type EnumObject = {
  [index: string]: string;
};

type EnumObjectResult = {
  [index: string]: {
    value: string;
  };
};
export const enumBuilderValues = <T = EnumObject>(
  constants: T,
): EnumObjectResult =>
  Object.keys(constants).reduce(
    (prev, curr) => ({
      ...prev,
      [curr]: {
        value: constants[curr],
      },
    }),
    {},
  );

export const graphqlEnumBuilder = <T = EnumObject>(name: string, values: T) =>
  new GraphQLEnumType({
    name,
    values: enumBuilderValues(values),
  });

Woovi is a Startup that enables shoppers to pay as they like. To make this possible, Woovi provides instant payment solutions for merchants to accept orders.

If you want to work with us, we are hiring!

Photo by Tom Hermans on Unsplash

How to reduce the file size of a PDF using Node.js

Samuel Durante — Mon, 17 Jul 2023 12:27:54 +0000

At Woovi, we allow our customers to upload their documents with arbitrary sizes without requiring them to reduce the file size on their side.

Therefore, when opening accounts, we need to perform this reduction on these documents. For this purpose, we have created an automated solution using Ghostscript with Node.js to handle the compression.

import { existsSync } from 'fs';
import fs from 'fs/promises';
import path from 'path';
import { promisify } from 'util';

const execPromise = promisify(exec);

const cwd = process.cwd();

const compressPdf = async (base64: string): Promise<string> => {
  try {
    const tempFolder = path.join(cwd, "temp");
    const hasTempFolder = existsSync(tempFolder);

    if (!hasTempFolder) {
      await fs.mkdir(tempFolder);
    }

    const originalFilePath = path.join(cwd, "temp", "original.pdf");
    const compressFilePath = path.join(cwd, "temp", "compress.pdf");

    await fs.writeFile(originalFilePath, base64, "base64");

    await execPromise(
      `gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook -dNOPAUSE -dQUIET -dBATCH -sOutputFile="${compressFilePath}" ${originalFilePath}`
    );

    const compressFileBase64 = await fs.readFile(compressFilePath, "base64");

    await fs.unlink(originalFilePath);
    await fs.unlink(compressFilePath);

    return compressFileBase64;
  } catch (error) {
    throw error;
  }
};

The above function creates a temporary folder to store the processed files and performs compression using Ghostscript parameters. The original file is saved in this temporary folder, and Ghostscript is used to generate a compressed version of the file. Then, the compressed file is read and converted into a base64 string.

Woovi is a Startup that enables shoppers to pay as they like. To make this possible, Woovi provides instant payment solutions for merchants to accept orders.

If you want to work with us, we are hiring!

Photo by Dan Dennis on Unsplash

How to know if your test is flaky?

Samuel Durante — Fri, 03 Mar 2023 20:38:43 +0000

What are Flaky Tests

Flaky tests are tests that pass sometimes, this can be due to some inconsistency inside it or other reasons.

How to debug a Flaky Test?

A way to find if a test is flaky is to run them N times, if at any point they fail this means that they are flaky.

Instead of repeatedly running tests and manually checking for failures, you can streamline the process by utilizing this script:

function jest-many-times-sequential() {
  i=1
  successes=0
  failures=0
  totalTests=$2
  SUCCESS_CHECKMARK=$(printf '\342\234\224\n' | iconv -f UTF-8)
  CROSS_MARK=$(printf '\342\235\214\n' | iconv -f UTF-8)

  until [ $i -gt $2 ]; do
    if yarn jest $1 --silent; then
      ((successes = successes + 1))
      echo "  $SUCCESS_CHECKMARK tests passed"
    else
      ((failures = failures + 1))
      echo "  $CROSS_MARK tests failed"
    fi
    ((i = i + 1))

  done

  echo "\n
  Ran Tests $totalTests times.\n
  ✅ Succeeded: $successes/$totalTests
  ❌ Failed: $failures/$totalTests
  \n
  "
}

To use this script, just paste the code block into your terminal's configuration file (.zshrc or .bashrc) and then restart your terminal.

Then you can run the script as follows:

$ jest-many-times-sequential <path-of-your-test> <times-to-run>

By running the tests N times sequentially, the script will automatically track the number of successful and failed runs, providing you with a final tally at the end.

Here is an example:

Now with this script we can validate if our tests are flaky or not.

Woovi is a Startup that enables shoppers to pay as they like. To make this possible, Woovi provides instant payment solutions for merchants to accept orders.

If you want to work with us, we are hiring!

Photo generated by DALL-E

Imperative X Declarative

Samuel Durante — Thu, 09 Feb 2023 14:18:48 +0000

Before making a comparison between the two models, it's necessary to understand the characteristics of each one of them.

What is the imperative paradigm?

The imperative paradigm is a programming model that is based on statements of actions or commands. In other words, an imperative program is nothing more or less than a sequence of commands for the computer to execute.

Example of an imperative program:

const array: Array<number> = [1, 2, 3];

function plus_one(array: Array<number>) {
  const arr = [];

  for (let i = 0; i < array.length; i++) {
    const element = array[i];

    arr.push(element + 1);
  }

  return arr;
};

console.log(plus_one(array));

As seen in this example, an imperative program is a sequence of commands given to the computer.

What is the declarative paradigm?

The declarative paradigm, on the other hand, states that the modeling of the program must be done through assertions about the objects. In other words, the programmer declares what they want the program to do, and the program's compiler or interpreter is responsible for determining the most efficient way to perform those actions.

Example of a declarative program:

console.log(
  [1,2,3].map((n) => n + 1)
);

In this example, the whole process of traversing the array, applying the function, placing it in a new array and returning, is omitted. Instead, a function from the language's own standard library is used, and the interpreter (Node.js, in this case) returns the expected value.

What's the difference between both?

The main difference between the declarative and imperative paradigm lies in how they express the program. In the imperative paradigm, the programmer directly manipulates the state of the data, while in the declarative paradigm, the programmer declares the relationships between the data and the operations to be performed on them.

The imperative paradigm is more straightforward and easier to understand, especially for novice programmers, while the declarative paradigm is more expressive and can be easier to maintain and scale as the program grows in complexity.

Conclusion

Ultimately, the choice between the two models depends on the type of problem being solved and the programmer's personal preferences.

Woovi is a Startup that enables shoppers to pay as they like. To make this possible, Woovi provides instant payment solutions for merchants to accept orders.

If you want to work with us, we are hiring!

When should you use test snapshots?

Samuel Durante — Wed, 09 Nov 2022 11:56:05 +0000

At Woovi we have more than 6000 tests. Constantly comes the doubt if we must use snapshots or not.

What is a snapshot?

Snapshot is a way of storing the expected return to guarantee that the return has always been the same.

When can you use a snapshot?

Let's imagine that we have an API, and we need all the fields to be defined, instead of doing this next:

expect(response.body.value).toBeDefined();
expect(response.body.expiresIn).toBeDefined();
expect(response.body.correlationID).toBeDefined();
...

We can use a snapshot in response.body, guaranteeing that all fields will be defined.

expect(response.body).toMatchSnapshot();

exports[`should return 3 fields 1`] = `
{
  "value": 1000,
  "expiresIn": 2592000,
  "correlationID": "correlationID",
}
`;

When can't you use a snapshot?

We saw that snapshots are good for verifying many fields, but otherwise, they are bad when you want to test a specific field.

For example, we need to verify if only 1 field is defined, instead of taking a snapshot, we can verify this field directly, like this:

expect(request.body.expiresDate).toBeDefined();

Taking snapshots for these cases makes testing confusing because you don't know the fields you are testing.

Woovi is a Startup that enables shoppers to pay as they like. To make this possible, Woovi provides instant payment solutions for merchants to accept orders.

If you want to work with us, we are hiring!

Photo by Alphacolor on Unsplash

How to use the Relay fetch policy to ensure fast rendering?

Samuel Durante — Tue, 11 Oct 2022 14:44:04 +0000

One of the main tools of Woovi is Relay. Relay is a GraphQL Client designed for high performance on any scale. When performing one of your main operations, query, we use a hook called useLazyLoadQuery, this hook has a property called fetchPolicy, which defines whether the query will be made from the local cache (we call it "store") or whether it should be made from a network request (we call it "network").

The following definitions fetchPolicy are:

store-or-network

store-or-network is the default value, if data exists in the store, and is not obsolete, it won't do a network request, otherwise, it will do a network request.

Example: We can use it in high-flow places to save network requests. Consequently avoiding unnecessary requests.

store-and-network

store-and-network will use the data of the store, and always do a network request without making regardless.

Example: We can imagine the Instagram home, we can render outdated data while fetching new data.

network-only

network-only always will search the data making a network request.

Example: We need to render the balance of the customer, we can't render a balance out of date, so always we will make a new network request without considering the store.

store-only

store-only always will search the data of the store.

Example: We use store-only when we assume that this data already exists in the store, and we will not need the refetch.

If you want to work with us, we are hiring!