Forem: One Beyond

Deploying a React + Vite SPA to a Private S3 Bucket with CloudFront and OAC

Pablo Eliseo — Wed, 19 Feb 2025 14:19:32 +0000

Deploying a React + Vite single-page application (SPA) to a private AWS S3 bucket while using CloudFront with Origin Access Control (OAC) requires careful setup, especially to handle client-side routing and asset paths properly. This guide will walk you through the complete process, highlighting critical aspects such as custom_error_response in CloudFront and the base config in vite.config.js.

1. Understanding How OAC, CloudFront, and S3 Work Together

What is Origin Access Control (OAC)?

OAC is a mechanism that allows CloudFront to securely access private content stored in an S3 bucket without exposing the bucket to the public internet. It replaces the older Origin Access Identity (OAI) with better security and fine-grained access control.

How CloudFront Works with S3 and OAC

S3 Bucket: Stores your static site files (HTML, JS, CSS, images, etc.). Since it's private, it cannot be accessed directly via a public URL.
CloudFront Distribution: Acts as a content delivery network (CDN), caching and serving requests efficiently.
OAC: Grants CloudFront permission to fetch content from the private S3 bucket.
Custom Error Handling: Ensures deep links and client-side routing work properly by redirecting 404 errors for non-existing objects to index.html.

With this setup, users access CloudFront, which in turn retrieves the content from the private S3 bucket, ensuring security and performance.

2. Setting Up the S3 Bucket

Since the S3 bucket is private, it must be configured to allow CloudFront access via OAC.

Terraform Configuration:

resource "aws_s3_bucket" "spa_bucket" {
  bucket = "react-vite-app"
  acl    = "private"
}

resource "aws_s3_bucket_policy" "bucket_policy" {
  bucket = aws_s3_bucket.spa_bucket.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Sid       = "AllowCloudFrontAccess"
        Effect    = "Allow"
        Principal = { Service = "cloudfront.amazonaws.com" }
        Action    = "s3:GetObject"
        Resource  = "${aws_s3_bucket.spa_bucket.arn}/*"
        Condition = {
          StringEquals = { "AWS:SourceArn" = aws_cloudfront_distribution.spa_distribution.arn }
        }
      }
    ]
  })
}

3. Creating a CloudFront Distribution with Custom Error Handling

A major challenge when deploying an SPA is handling client-side routing. When a user directly visits /dashboard or /profile, CloudFront will look for dashboard/index.html or profile/index.html in S3, which doesn't exist. To fix this, we use custom_error_response to serve index.html whenever CloudFront encounters a 404 error.

Why Use `custom_error_response`?

SPAs rely on client-side routing. The React app should handle the routes, not CloudFront.
Prevents 404 errors. Instead of returning a 404 from S3, CloudFront serves index.html, allowing React to handle the routing.

Terraform Configuration:

resource "aws_cloudfront_distribution" "spa_distribution" {
  enabled = true

  origin {
    domain_name = aws_s3_bucket.spa_bucket.bucket_regional_domain_name
    origin_id   = "spa-s3-origin"
    origin_access_control_id = aws_cloudfront_origin_access_control.oac.id
  }

  default_cache_behavior {
    allowed_methods  = ["GET", "HEAD"]
    cached_methods   = ["GET", "HEAD"]
    target_origin_id = "spa-s3-origin"
    viewer_protocol_policy = "redirect-to-https"

    forwarded_values {
      query_string = true
      cookies { forward = "none" }
    }
  }

  custom_error_response {
    error_code         = 404
    response_code      = 200
    response_page_path = "/index.html"
  }
}

It is very important here not to use the origin_request_policy_id = "216adef6-5c7f-47e4-b989-5492eafa07d3" # AllViewer - Default ID as the AllViewer request policy forwards the host to the S3 bucket which will be configured to only accept requests from Cloudfront.

4. Why Use Vite Instead of Webpack?

Advantages of Vite

Faster Development: Vite uses native ES modules, significantly improving development speed compared to Webpack.
Better Performance: It only rebuilds changed files instead of bundling everything together.
Optimized Build Output: Vite produces highly optimized static assets, reducing bundle size and improving load times.

For SPAs, especially with React, Vite provides a better developer experience and faster deployments.

5. When to Use This Approach vs. Other Alternatives

Use This Approach When:

You need a pure client-side application without server-side rendering (SSR).
You want cost-effective static hosting with high security.
You want full control over AWS infrastructure.

Consider Other Options When:

Next.js: If you need SSR or static site generation (SSG), Next.js on Vercel or AWS Lambda may be a better choice.
Gatsby: If your site is primarily static content with pre-built pages.
AWS Amplify: If you prefer a managed service that simplifies the deployment process.

6. Configuring Vite for Correct Asset Paths

Why the `base` Option in `vite.config.js`?

Vite's base configuration determines how URLs are resolved in the generated output. If not set correctly, assets (JavaScript, CSS, favicon) may try to load from incorrect paths when navigating to deeper routes.

Why Use `base: '/'`?

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

export default defineConfig({
  base: "/", // Ensures all assets use absolute paths from the root
  plugins: [react()],
  build: {
    outDir: "dist",
  },
});

7. Deploying with GitHub Actions

To automate deployment, we use GitHub Actions to build and upload the React app to the S3 bucket. I am using Github Actions Secrets and Variables for configuring the workflow.

name: Deploy to S3
on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v3
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 18
      - name: Install Dependencies
        run: npm install
      - name: Build Application
        run: npm run build
      - name: Configure
        uses: aws-actions/configure-aws-credentials@v4.0.2
        with:
          aws-region: "${{ vars.AWS_REGION }}"
          role-to-assume: "arn:aws:iam::${{ vars.AWS_ACCOUNT_ID }}:role/github-actions_role"
          role-session-name: "GitHub-Actions_Publish_Static_Site"
      - name: Deploy static site to S3 bucket
        run: aws s3 sync ./dist/ s3://${{ vars.AWS_S3_BUCKET_NAME }} --delete --region ${{ vars.AWS_REGION }}

Also, I am configuring the AWS credentials by using a IAM role. See this guide for more information on the topic.

Conclusion

This guide covered deploying a React + Vite SPA securely on AWS using S3, CloudFront, and OAC. By setting up CloudFront with custom_error_response, using Vite for efficient builds, and automating deployment with GitHub Actions, you ensure a smooth, performant, and cost-effective solution for hosting your SPA.
You can find the full code (with some more improvements) in this GitHub repository

Stress Management

Anna Csurgai — Wed, 24 Apr 2024 09:30:37 +0000

As we reviewed in the first part of this blog series, the starting point for stress management is awareness of our stress levels. Once we realize we are stressed, we often unconsciously ask ourselves the following questions:

Can we manage the situation?
Is it within our control?
Can we solve it?
What solutions do we see?
If we can't manage it, how should we cope?

In this blog, we delve into various aspects of stress management, exploring concepts like the three main arousal responses to stress and the difference between problem-focused and emotion-focused coping strategies. The stress container self-reflective task helps us analyse our mood and identify actions we can take. Additionally, we'll discuss tips for managing workplace stress and the importance of our shields, which act as protective factors against stress and anxiety. Towards the end, you'll find thought-provoking questions to reflect on your coping mechanisms.

Fight vs flight vs freeze (& fawn)

There is a general concept of how we and our bodies react when we perceive threats.

The fight response activates a person to cope with perceived threats by taking action to eliminate the danger. It results in physical changes like increased heart rate, higher blood pressure, adrenaline rush, and tightened jaw.
The flight response involves escaping the danger, seeking safety and distance from the source of the stress. This response triggers a cascade of physiological changes, including a surge in adrenaline, rapid heartbeat, shallow breathing, and tense muscles. The body readies itself for swift escape, prioritizing survival above all else.
In contrast, the freeze response involves a state of immobility, where the individual becomes momentarily paralyzed in the face of danger. Rather than confront or flee, they may find themselves unable to act, as if caught in a state of suspended animation. This response is characterized by a decrease in heart rate and muscle tension, often accompanied by a sense of detachment or dissociation from the surrounding environment.
Lately, research has identified a fourth stress reaction pattern: fawn. This is a little bit similar to the freeze response, but its core aspect is that we try to please and appease the needs of someone else, instead of prioritizing our own well-being, so in the end we become more submissive in the situation.

Problem-focused or emotional-focused

The problem-focused coping strategies aim to change or eliminate a stressor. When you employ a strategy aimed at directly addressing the stressor itself, you are engaging in problem-focused coping. For instance, devising plans, solving problems, or removing the stressor altogether are all forms of problem-focused coping.
Emotion-focused coping is when you try to deal with your emotional response to the stressor. If you are trying to reduce, eliminate, or simply tolerate your emotional response to a stressor, then you’re using emotion-focused coping. Examples include withdrawal, expressing anger and frustration, seeking emotional support, distracting oneself, engaging in rumination, and accepting resignation (acknowledging that the problem may persist).
For example, if we have a higher workload, prioritizing our tasks or delegating them is a problem-focused solution, but acknowledging and celebrating small victories or milestones to stay motivated is more about emotion-focused coping.

Our Stress Container

The Stress Container model illustrates how individuals manage everyday stresses based on their level of vulnerability. Those with low vulnerability possess larger containers, making them less susceptible to mental health issues. The size of the container can be due to a lot of factors from someone’s background, like the patterns that we went through in the previous part of this blog series.

When the container overflows, individuals may experience mental and physical illness. This is a learning process to check & identify when our container is filling and we have to actively manage what is in there.

Workplace stress

Most of us experience stress during our personal lives but experience it more heavily during work. Most of the time we cannot show or express that we are stressed when we work, so we must minimize what our environment sees from it. In this case it is truly important to have some time for ourselves after a harsh meeting or project demo or the day itself where we can express it or reward ourselves after a hard day or period.

Some key tips to manage our daily stress:

Taking a break from work is needed, especially since our need for rest is rising with the increased spent time without rest, so we should install breaks within our days and our schedule. Sometimes it is hard especially when we work remotely, to just walk around, or have a few minutes as a break while when we work in the office. Our environment can help us like having a coffee together or just chatting about something. However,
Morning routine can be key when it comes to keeping balance within our lives. Having some activity to do before we jump to our laptops can be hugely beneficial. Since remote working is truly part of our DNAS, we intend to start our day with coffee and our duties. Well, I cannot say that it never occurred to me, but I enjoy my day more if I have some time before I start working. This can be reading or doing sports, having your big walk with your dog or learning something. It does not have to be long activity, even 20-30 minutes are sufficient to have the feeling that you have already done something for yourself.
Setting up boundaries is not an easy task to do. We have a lot of priorities and duties, and we can be overwhelmed with these and the feeling that we want to execute as many tasks as we want to and help as many colleagues as possible. However, assertively declining extra commitments and clearly communicating availability and preferred communication methods are needed to create transparency and take care of ourselves.
Leaving work behind is not easy, switching off our working- mode, work-persona is essential, here are some tips:
- Develop a shutdown routine to signal the end of the workday. This could include tidying your workspace, reviewing your tasks for the next day, and mentally transitioning out of work mode.
- Prioritize Tasks: Before leaving work, prioritize your tasks for the next day. Knowing what needs to be done can ease your mind and help you relax during your time off.
- Unplug: Disconnect from work-related communication channels, such as email and work chat apps, when you are off the clock. Consider turning off notifications or even deleting work apps from your personal devices.

Our shields

We can say that we can arm ourselves against stress; this is what we can call “protective factors”. This includes elements that can be obvious for some of us, but we can easily look over these under a stressful period and let go of the elements of a healthy lifestyle with charging and cheerful relationships.

Sports: Being active and taking care of our physical fitness is a protective factor against stress. It helps us to create balance within our lives, so it helps to relieve stress unconsciously. Additionally, we can use it as a conscious coping strategy, when after a hard-working day we decide to go for a run or a walk with our dog, or during a weekend having a trip in nature – all of these help us to manage our stress level and we can experience an eustress after an activity that we made it.
Nutrition plays a huge part in how we feel daily. Whether we feel energized or fatigued depends on the micro and macro nutrients that we give to our body through foods.
Sleep: Rest is essential. Even if we eat well and engage in activities, if we do not sleep well or enough, we can harm ourselves. Sometimes sleep problems occur first when we tip over our balance, either we have restless nights, or we feel that we cannot sleep enough to rest. Based on scientific research like this we should aim for 7-9 hours per night in order to have proper time for regeneration.
Hobbies: Having time for your hobbies is great for recharging. Sometimes we skip this easily when we have a lot of things to do at work, which for a brief period of time can be an adaptive coping mechanism, but if we lose an activity whose aim was to refill our batteries then we cut out.
Mindfulness: Being in the present has not been harder than during the last couple of years with our accelerated world. Incorporating mindfulness into our daily lives can help us manage stress.
- Practice mindful breathing: When you are feeling stressed or overwhelmed, take a few moments to focus on your breath. Close your eyes if possible, and take slow, deep breaths, paying attention to the sensation of the air moving in and out of your body. This simple mindfulness exercise can help calm your nervous system, bring you back to the present moment, and reduce the impact of stress.
- Engage in mindful activities: Incorporate mindfulness into your daily routine by engaging in activities with full awareness. Whether you are eating, walking, or washing dishes, try to focus on the present moment and fully engage your senses. Notice the sights, sounds, smells, and textures around you without judgment. By bringing mindfulness to everyday activities, you can reduce stress and increase your overall sense of well-being.
- Practice self-compassion: When you are feeling stressed, it is easy to be hard on yourself or engage in negative self-talk. Instead, practice self-compassion by treating yourself with kindness and understanding. Remind yourself that it's normal to feel stressed from time to time, and that you're doing the best you can in this moment. Offer yourself words of encouragement and support, just as you would to a friend in need. Mindfulness can help you cultivate a greater sense of self-compassion by allowing you to observe your thoughts and emotions with greater clarity and acceptance.

As we can see, everything comes back to self-care, knowing our self and boundaries and paying attention to our body and soul. By understanding our stress responses and adopting a balance of problem-focused and emotion-focused coping strategies, along with taking care of ourselves and our lifestyle, we can effectively manage stress and foster resilience in our daily lives.

Some takeaway questions which can help you to reflect on your copings and stress management techniques:

What are my go-to strategies for managing stress? Are they primarily problem-focused or emotion-focused?
How effective are my current stress management techniques in helping me cope with different stressors?
If I look at my stress container, what elements are within it? Is it overflowing? Can I take some elements from it?
Do I tend to prioritize self-care, such as taking breaks, engaging in hobbies, or practising relaxation techniques, during stressful periods?
How well do I set boundaries between work and personal life? Do I struggle to disconnect from work-related stressors?
What role does physical activity play in my stress management routine? Am I consistently incorporating exercise into my daily or weekly schedule?
What adjustments can I make to improve my sleep quality and ensure I get enough rest to support my well-being?
How mindful am I of my thoughts and emotions during stressful situations? Do I practice mindfulness or other forms of mental relaxation regularly?
Do I have a support system in place for seeking help or guidance when I feel overwhelmed by stress?

Know your patterns

Anna Csurgai — Wed, 17 Apr 2024 08:52:59 +0000

We are all different, and we each have our own ways of detecting stress; stressors impact us at varying levels, influencing our stress levels differently. Today’s article is all about understanding yourself, emphasising the importance of recognising your patterns, while keeping in mind that we are the protagonists of our lives and providing some key takeaway thoughts and questions.

Patterns from your family

Our familial environment imparts patterns, best practices, and guidance for various aspects of our lives. We observe how our parents react to challenges in their jobs and family lives, and these behaviours shape our own responses. This unconscious programming evolves through experiences in kindergarten, elementary, high school, and university.

Patterns from school

Our relationship with performance is largely defined during our formative years in school. For many, coping mechanisms are first consciously experienced in this setting. We can develop positive habits such as open communication with friends and family about our problems or taking personal time to recharge. However, we can also adopt harmful habits like using maladaptive coping mechanisms such as excessive video consumption, following news obsessively, or turning to substances like smoking, drinking, or drugs to escape stress.

Patterns from your workplace

Our first workplaces hold a special place in our lives because they introduce us to the functioning of a workplace as we enter the labor market. Naturally, our previous patterns influence the type of workplaces we prefer and feel comfortable in, and we bring our personal coping mechanisms to each new environment.
Furthermore, we not only influence group solutions to problems but also adapt to the coping mechanisms of our peers and the company. We learn how to cope with unexpected situations, how to communicate effectively, what steps to take if initial attempts fail, and how to support one another.
While it is not solely our responsibility to change established practices within a larger community, what we can and must do is reflect on our coping strategies, identify areas for improvement, take action, and speak up when we encounter unhealthy coping patterns.

Your place in it

After considering all the environmental influences we've absorbed since childhood, it's difficult not to conclude that we should just adapt to what we've been given. Well, of course, there are some aspects of our lives when we are not in charge of making decisions and actions. But we are not there anymore. What we inherited is one thing, but how we process it and how we cope with the incoming stressors is something that we can influence, and we can make it better.

Self-knowledge and self-reflection are vital for stress awareness and management. By understanding our own patterns, we can better navigate stressors and develop healthier coping mechanisms. To facilitate this process, below are some thought-provoking questions:

Takeaway questions:

Family Experience:

How do you recall stress being managed or expressed within your family while growing up?
What was your feeling: could your parents communicate their issues with each other?
What were the primary stressors in your family environment, and do you notice any similarities between those and your current stress triggers?
Reflect on the coping mechanisms you observed or adopted from your family members when dealing with stress. Are these mechanisms still effective or do they contribute to your stress?
Are there any recurring patterns or dynamics in your family that you find mirrored in your own stress responses?

School Experience:

Can you recall specific periods or events during your schooling that significantly increased your stress levels? How did you cope with them then, and how do you cope with similar situations now?
Reflect on the academic pressures or social dynamics in school that might have contributed to your stress patterns. Do you find yourself experiencing similar pressures in your current life?
How did teachers or peers influence your stress management strategies during your school years? Are there any habits or beliefs you developed during this time that you still carry with you?

Workplace Experience:

Reflect on your earliest job experiences. What were the main stressors you encountered, and how did you initially cope with them?
How have your stress triggers evolved as you progressed in your career? Are there any recurring themes or patterns in the stressors you face at work?
Consider the organizational culture and management styles of your past and current workplaces. How have these factors influenced your stress levels and coping mechanisms?
Have you observed any unhealthy patterns or behaviours in your professional life that contribute to your stress? How do you plan to address or change these patterns moving forward?

General Self-Reflection:

What similarities do you notice between the stress triggers and patterns you've identified across different areas of your life (family, school, work)?
Are there any specific events or experiences that stand out as particularly influential in shaping your current stress responses?
How do you typically react to stress? Are your reactions primarily emotional, physical, or behavioural? (We have reviewed the reaction types in our first blog of Stress Awareness Month series so you can check here)
Reflect on the effectiveness of your current stress management strategies. What adjustments or improvements could you make to better address your stress triggers and patterns?

Stress Awareness

Anna Csurgai — Wed, 10 Apr 2024 08:35:35 +0000

Stress is part of our everyday life; it is a normal thing to be stressed sometimes. So, someone could ask: then what is the deal about it? Why should we highlight this when it is an essence of our lives?

Well, it is true that we cannot block ourselves from stress unless we decide to leave our society and enter a monastery, but even there, we would face stress and internal movements. So, the upcoming questions remain: how can we live and cope with it? Can we detect it when we feel stressed? Do we know what are our patterns? Can we manage it? What do we do if we feel stressed when we are not under control? How can we protect ourselves in these highly stressful situations? What kind of protective factors can we make to have balance in our lives?

April is International Stress Awareness Month, so we aim to cover with a three-part series of blogs the questions of stress awareness, our patterns and coping strategies. As part of our Mental Health First Aider community and with my studies in psychology, I thought that it would be beneficial to have an overview of this topic and make some time for us to reflect on our connection with stress.

Stress & stressors

Stress is how we react when we feel under pressure or threatened. It typically arises when we find ourselves in circumstances that we perceive as beyond our ability to manage or control. Of course, there are cases when this stress level is negotiable and we think that the situation is under our control, and this eustress has a facilitator mode. However, if the stressor is too intensive or our capabilities are not enough to control or fight with the situation then we can label it as distress. Generally, we can say that long-lasting or intensive stress can have serious impacts on our lives.

Stress & Self-awareness

We could think that it is a natural thing to be aware of being stressed, but it is not that simple. For example: If someone grows up believing stress is normal and emotional instability is common in their family, they're likely to seek out similar situations in their relationships and workplaces. Even if it's not healthy, we often gravitate towards what's familiar because it feels safe.
Sometimes it is not easy to realize that what we feel – whether it's long-lasting or intense stress – is maladaptive or that we are overwhelmed by it. Therefore, it is recommended to take some time regularly to conduct a self-check analysis, where there is an opportunity to observe our current psychological, physical, and behavioural states. We can divide the symptoms into 3 categories:

Common Psychical symptoms:

Sleep problems
Headache
Fatigue
Indigestion
Chest pains and high blood pressure
Difficulty breathing
Blood pressure increased
Sudden weight gain or weight loss
Feeling sick, dizzy or fainting
Panic attacks

Common Physiological symptoms:

Feeling anxiety, nervousness and afraid
Irritability, angry or impatient
Over-burdened or overwhelmed
Your mind is a buzzing hive of activity, unable to calm.
Lack of concertation
Neglected or lonely
Depressed
Mental health problems occur or existing ones getting worse

Common Behavioural symptoms:

Withdrawal from social activities or isolating yourself from others
Increased use of substances (like alcohol, tobacco, or drugs)
Changes in eating habits (overeating or undereating)
Procrastination or avoidance of tasks that feel overwhelming
Difficulty relaxing or enjoying leisure activities, hobbies
Performance difficulties

Recognising these signs early allows you to take proactive steps to manage stress before it escalates and leads to potential stress-related issues or burnout. It's important to remember that everyone experiences stress differently, so being mindful of your own unique signs and symptoms is crucial. Plus, it is also beneficial if you are open to observing and learning your loved ones’ behaviours when it comes to stress. By paying attention to these signals, you can develop strategies to cope with your stress effectively and be supportive of your family and friends.

Some takeaway questions which can help you to raise your awareness and self-knowledge:

What kind of symptoms do you face when you are stressed?
What are the stressors that you are highly sensitive to?
Reflecting on your past experiences, have there been times when you ignored the signs of stress until it became overwhelming? What did you learn from those experiences?
Reflect on the physical, psychological, and behavioural symptoms of stress listed in the article. Which of these symptoms do you tend to experience most frequently, and how do they manifest in your daily life?
Imagine a scenario where you feel stressed but are unable to identify the cause immediately. What steps can you take to explore and address the root of your stress?

Mentor tools VII - Set up goals

Irene Mateo Herrero — Fri, 15 Mar 2024 13:43:29 +0000

Is it time to help your mentee set up their goals for the year and you don't quite know how to do it?

Or maybe you need a guide to set up your own goals?

Setting goals may seem like a simple task, but how many times have you failed to achieve your goals? How many times has a mentee set a goal at the beginning of the year and by the end of the year it was half done or not even started?

To increase the chances of achieving your goals, it is essential to choose them and formulate them well. I usually hold a specific meeting (or even two) with my mentees for this purpose. I listen carefully to their ideas but, above all, I ask a lot of questions to help them clarify and make their own decisions.

Do you want to know how I approach the meeting in which my mentees set their goals? Read on!

Step 1: Ask, ask, ask

Choosing goals is a very personal decision. Maybe it has happened to you that someone has said "Hey, why don't you do this?" and you, even knowing that it was in some sense positive for you, have not found the motivation to do it or have not given it enough priority.

The reason this happens is that we each have our own abilities, limitations, motivations, priorities... so it is very difficult for someone else to propose something to you that connects and fits with all of this. But there is someone who can hit the nail on the head: YOU.

However, we sometimes do not have very clear ideas because we have not stopped enough to know ourselves and discover what moves us, what we like, what our priorities are... this can happen to our mentees and this is where our work as mentors comes in.

To help your mentee to define their goals, the best thing you can do is to ask questions.

These questions will make them reflect and, with the conclusions obtained, they will be able to choose and formulate goals for which it will be easier to find motivation.

This doesn't mean that you can't give your opinion or suggestions at some point in the conversation, specially if it is your mentee who asks you about them. But, in my experience, your questions and your active listening will be more valuable, at least in this initial phase of goal setting.

Furthermore, think about the goals that your previous mentees have accomplished and which ones have not. Have they been the ones they proposed themselves? Or the ones you proposed to them? Perhaps the ones with a mixture of their ideas and your contributions? I invite you to this reflection.

In any case, if you have always been more about proposing ideas than asking and listening, I challenge you to change the dynamic. Ask and listen more than you talk. At first it will be strange, you will feel that you are too quiet or that you contribute too little. But give yourself time, observe the results, and draw your own conclusions.

At this point you may be thinking, but what exactly do I ask my mentee?

Well, in this section I am going to give you a list of questions you can ask. But first, I will give you some advice.

The first one is that you don't have to ask all the questions and not in a specific order. You will be the one who, as the conversation flows, will select them with your magical intuition as a mentor and the practice you acquire.

The second is that before the meeting with your mentee, you practice reading the questions and answering them yourself to refine any of your goals. You will then be able to adapt the questions to the way you speak so that you feel more comfortable. Or you may want to change the order, add or delete some questions... I encourage you to make this questionnaire your own.

That said, let's get to the questions list:

Initial questions: Are you clear about what goals you want to set?
- Yes: listen to their ideas and go directly to Block 1. Go through all the following blocks of questions for each one. The idea is to refine them one by one.
- No: ask some of the following brainstorming questions before moving on to the next block:
  - How do you see yourself professionally in (1/2/5) years?
  - What will you have learned that you don't know now?
  - What hard/soft skills will you have that you don't have now?
  - What challenges will you have faced?
  - What responsibilities will you have?
  - What do you need to do to get there?
  - Where would you like to start?
  From these questions will come ideas for possible goals. Go now to Block 1 and talk about each goal independently to get them refined.
Block 1: Alignment with their motivations:
- What do you want to achieve this goal for?
- What will be the reward for you?
Block 2: alignment with the needs of the company:
- Will you be able to bring value to the company by doing this objective?
  - Yes: Great!
  - No:
    - Is there any way to reformulate it so that it brings (more) value?
    - Do you want to keep this goal even though it does not seem to bring (enough) value to the company?
  In case your mentee wants to keep a goal even though it does not bring (enough) value to the company (maybe it does bring value to themself and that is enough for them), I recommend you to warn them that, the more aligned their goals are with the company's needs, the more likely they will be compensated. You can read more about promotable goals here.
  
  In case they don’t want to keep that goal you will discard it and take another idea from their list of possible goals. Ideally, start the questions again from the beginning of Block 1 to refine the new goal. This can happen throughout the entire questionnaire and, in fact, it is not a bad thing to discard goals, as it will mean that you are refining them well.
Block 3: define SMART objective. A SMART goal has the following characteristics: it is SPECIFIC, MEASURABLE, AMBITIOUS*, REALISTIC and TIME-BOUND.

Thanks to these characteristics the goal has more chances to be fulfilled. Therefore, we are going to ask some questions to "transform" it because, surely, the goal as you have set it up to now does not have these characteristics.
- Specific:
  - What exactly do you want to achieve (e.g. if your proposal is "improve my soft skills", it is about you reflecting on what exactly you want to improve until the objective is specific enough, e.g. "Learn to set boundaries and manage customer expectations assertively").
  - What is it for you to... (e.g. if they tell you they want to "write better code" you can ask "What is it for you to write better code?" so that they become more aware of what they want to work on specifically).
- Measurable:
  - How will you know that you are making progress on your goal?
  - How will you know that you have achieved it?
- Ambitious*:
  - Is it a challenge for you?
  - (If not) How could it become a challenge?
- Realistic:
  - To what extent is it up to you?
  - What options for success do you see from 0 to 10?
  - If the chances of success you see are low:
    - How could you redefine it to increase the chances of success?
    - Do you want to keep refining this goal despite the low chances of success?
  - What resources do you need to achieve it (e.g. time, help from others, training, budget...)?
  - How can you get the resources you lack?
  - What could prevent you from achieving it?
- Time-bound:
  - When do you want to start working on it?
  - When do you want to have it completed?
  - What intermediate stages might there be?
Block 4: check commitment
- What level of commitment do you have to this goal from 0 to 10?
- If your answer is less than 9:
  - Is there any way to adapt the goal so that your commitment reaches 9?
  - Do you want to choose this goal in spite of it?

And that’s all from the questioning phase.

At this point your mentee will have a good idea about the goals they want to choose. You will also have tested and refined them with questions to increase the chances of success.

You already have 90% of the work done! You can move on to the next step.

Step 2: Write down the goals

Now all that's left to do is to write down these goals. It is likely in your company you have a tool or space where these goals can be collected.

I recommend that you encourage your mentee to access this space and write them down themself. This way you will foster their autonomy and, besides, who better than them to explain what they want to do and how they are going to do it?

To ensure that the objectives are well written, I suggest you fill in this template for each of them:

Title of the objective

I want to... (general objective)
That will have an impact on... (describe personal & company impact)
For that I am going to... (milestones)
I am going to need...
I want to finish it by (deadline)

And that’s it!

I hope you find these tips useful and see you in the next article.

Note: In some sources, the A from SMART goals can also mean “attainable” or “achievable”.

Mentor tools VI: First 1:1

Irene Mateo Herrero — Tue, 05 Mar 2024 18:10:52 +0000

Is this your first time mentoring and you have your first one on one coming up?

Or maybe you've been a mentor before but are just starting to mentor a new partner?

In any of these cases, you may feel a bit of concern or uncertainty. This is normal, because the first contact with a new mentee is an important moment in the mentoring process:

We begin to build the relationship of trust and the safe space.
We start to know their motivations and expectations regarding their professional growth.
We begin to define what they will need from us and/or the company to achieve their goals.
We establish the basis of the mentoring relationship (responsibilities, frequency and duration of the sessions...).

Therefore, I want to give you some tips to face this first 1:1.

Before the 1:1

I recommend that before the first 1:1 you gather information from your new mentee:

their role and seniority
professional background (in your company but also previous)
outstanding skills and achievements
areas for improvement
relationship with colleagues and clients
project/area in which they work

All this you can extract from several sources, for example:

their manager, a co-worker, their previous mentor.
documentation about their performance (their latest Performance Review, Peer Feedback, Manager Assessment or any other document with updated information).

This information will be useful for you to gain context about your mentee. However, along with the objective data you get, such as their role or seniority, you will probably receive more subjective information, such as evaluations about their way of being or their relationships with other colleagues.

I advise you to be cautious with this information, especially if it is not positive information. It is important to keep in mind that each of us brings our own subjectivity to our view of others and, therefore, you may receive data affected by the biases of the people who gave it to you. So, I recommend that you gather information, but keep an open mind.

During the 1:1

The day of your first 1:1 has finally arrived!

I recommend that you mute all notifications and prepare yourself to give your full attention to what your new mentee is going to tell you.

Here are some tips on how to approach this first meeting:

Welcome them to this space.
Explain the objectives of the meeting.
- Get to know each other
- Establish the basis of the mentoring relationship
Introduce yourself. You will probably tell them about your professional background, but I also recommend that you share some personal and/or less formal information. This will help to generate a safe space or climate of trust in which your mentee will gradually feel more open to share.
Ask for them. Although it is important to make yourself known, the protagonist of the mentoring sessions is your mentee. Therefore, asking and listening is fundamental from day 1. Some professional questions especially relevant to our work as a mentor will be:
- What motivates you most about the work you do?
- What are the skills you would highlight about yourself?
- What are your areas of improvement?
- What are your expectations for your professional growth?
- Where would you like to move forward?
Establish the basis of the mentoring relationship. Now that you know each other a little better, it's time to talk about the mentoring sessions. At this point, I advise you to ask them if they have any mentoring experience, either being a mentor or being mentored and how it went. You can then explain how you understand the mentoring process and how you usually approach it. I usually explain the following:
- Role of mentoring: to accompany the mentee to grow professionally.
- Structure of the sessions: I normally cover two main topics:
  - Follow up of daily work (project, client, company...).
  - Follow up of goals
- Frequency and duration: in my case, I establish 1 session per month as a minimum in order to be able to follow up on a regular basis. However, I always leave the option to my mentee to choose if they want to have 1:1s more frequently (one session every two weeks, every three weeks...).
  
  Regarding the duration, you can also agree with your mentee. I usually reserve between 30 and 45 minutes depending on the frequency. Less frequent 1:1s tend to be longer.
- Other matters: I always remind my mentee to:
  - Feel free to ask or express whatever you want, this is a safe space.
  - Ping me if you need to talk before the next 1:1.
  - You can give me feedback on the sessions at any time. The purpose is that these sessions are useful to you and help you in your growth.
Finally, after explaining all this information to my mentee, I ask them:
- Do you find what I propose useful?
- Do you think you might need something I haven't told you?

Listen carefully to their views, discuss it if needed and you will have completed your first 1:1!

You can close the meeting by setting the date of your next meeting and thanking them for their time.

You can also advance the topic of the next session if it will be, for example, the meeting to define their goals. This way, they can ask you now if they have any questions.

That’s all, see you in the next one!

Azure Service Bus 101: Introduction to Queues and Messaging

Ignacio Ripoli — Thu, 18 Jan 2024 23:15:55 +0000

Introduction

Azure Service Bus acts as a dependable communication system within the world of cloud computing, enabling secure and reliable interactions between various applications and services.

Compared to other messaging systems, Azure Service Bus offers advanced functionalities. It provides a great framework for different components of an application to communicate effectively and securely.

Using Azure Service Bus involves setting up communication between applications and services. You can create these pathways, send messages between them, and configure how messages are handled.

Throughout this discussion, we'll dive into the features and capabilities of the Service Bus and explore how it can be effectively utilized in diverse applications and scenarios.

You will need an Azure account. I invite you to create your first Azure account by clicking on this link.

Throughout your reading, you will see how to:

Send messages in a queue,
Consume messages in a queue,
Send messages using topics,
Subscribe to a topic and receive messages,

Regarding the code, most of the calls will be non-blocking and therefore asynchronous; a good understanding of async is essential, you can find more info about it here.

Azure Service Bus — Overview

Azure Service Bus facilitates the separation of data with a focus on both reliability and security.

Azure Service Bus provides us with the ability to leverage various scenarios:

Sending messages in a Queue,
Decoupling applications for improved reliability and greater scalability

We know that Azure Storage Queue allows:

Storing over 80GB of messages in a queue,
Tracking message processing progress,
Accessing activity logs,

Although Azure Service Bus doesn't have these three advantages, it offers compelling functionalities that aren't available at the Azure Service Queue level:

Receiving messages without needing to query the queue,
A 1-to-N relationship between publishers and subscribers through Topics,
Implementing workflow coordination and multiplexed transfers that require strict message ordering or message deferral,
Service Bus ensures FIFO (First In First Out),
Support for the AMQP protocol and other features,

The First In, First Out (FIFO) principle is a method used in queue management, where the first item to enter the queue is the first to be processed or serviced, following a sequential order. This principle ensures that items or elements are processed or dealt with in the same order they were received, without any prioritization or reordering based on urgency or importance. It's a fundamental concept in managing queues and is commonly used in various computing and business scenarios where order preservation is critical.

If you find yourself in any of the mentioned scenarios, Azure Service Bus is your ally.

Azure Service Bus is a fully managed enterprise message broker with message queues and publish-subscribe topics (in a namespace). Service Bus is used to decouple applications and services from each other. <

Azure Service Bus — Queues

The queues will allow us to store the sent messages until the consumer requests them for processing. Below is what a Queue looks like.

In summary, a queue is:

A temporary storage warehouse for messages,
Messages are delivered upon the consumer's request,
The receiver consumes messages starting with the one that arrived first, following the First In First Out principle.

Example of Use
We have two services:

The first service creates users.
The second service handles notifications, sending emails and/or push notifications to our users after their creation.

In our example, it is possible to subscribe our notification service to the 'notification' queue, which receives messages such as 'UserCreated' with the property 'UserId = xxx'. This identifier will be used by the notification service to send a welcome email.

Azure Service Bus — Topics

Topics provide the ability to have a provider with multiple observers or consumers, each consumer having its own queue that feeds it.

Example of Use
Let's consider the following scenario:

A user creation service
Several microservices (notification microservice, articles microservice, product microservice, etc.)

In our case, upon creating a new user, the service will notify through a topic to different subscribers/microservices about the creation of a new user. This allows other services to:

Send the user a confirmation of the account creation,
Add the user's identifier in the schema of the Article microservice's database to send them new articles,
Add the user's identifier in the schema of the Product microservice's database to notify them about promotions, new products, etc.

In practice?

Sign in to Azure Portal:
- Go to portal.azure.com and log in to your Azure account.
Create a new Service Bus namespace:
1. Click on "+ Create a resource."
2. Search for "Service Bus" and select it.

Fill in details for the new namespace (subscription, resource group, name, region, and SKU).
Click "Review + Create," then "Create" to start deployment.

Review and deploy:
- Review configuration details and initiate the deployment process.
- Wait for the deployment to complete.

Access your Service Bus:
- Once deployed, find your Service Bus namespace under "All resources."
- Explore and manage your Service Bus, create queues, topics, or subscriptions as needed.

Within your Service Bus namespace, you can create queues, topics, subscriptions, and manage various settings based on your application needs.
Click on "Queues" or "Topics" to create a new queue or topic and set up subscriptions or rules according to your messaging requirements.

Creating Queues

import { ServiceBusClient } from '@azure/service-bus';

async function createQueue() {
  const connectionString = '<YOUR_CONNECTION_STRING>'; // Replace with your Service Bus connection string
  const queueName = '<YOUR_QUEUE_NAME>'; // Replace with your desired queue name

  const serviceBusClient = new ServiceBusClient(connectionString);

  try {
    const queueOptions = {
      // Define queue options if needed
      // For example:
      // defaultMessageTimeToLive: 60 // Message time-to-live in seconds
    };

    const queueDetails = await serviceBusClient.createQueue(queueName, queueOptions);
    console.log(`Queue "${queueDetails.queueName}" created successfully.`);
  } catch (error) {
    console.error('Error creating queue:', error);
  } finally {
    await serviceBusClient.close();
  }
}

// Call the function to create the queue
createQueue();

Sending a message

const { ServiceBusClient } = require('@azure/service-bus');

async function sendMessageToQueue() {
  const connectionString = '<YOUR_CONNECTION_STRING>'; // Replace with your Service Bus connection string
  const queueName = '<YOUR_QUEUE_NAME>'; // Replace with your queue name

  const serviceBusClient = new ServiceBusClient(connectionString);

  try {
    const sender = serviceBusClient.createSender(queueName);
    const message = {
      body: 'Hello, Azure Service Bus!', // Replace with your message payload
    };

    await sender.sendMessages(message);
    console.log('Message sent successfully to the queue.');
  } catch (error) {
    console.error('Error sending message:', error);
  } finally {
    await serviceBusClient.close();
  }
}

// Call the function to send the message
sendMessageToQueue();

This JavaScript code uses the ServiceBusClient class from the @azure/service-bus package to create a sender for the specified queue and sends a message with a simple payload, and the ServiceBusClient package to create a sender for the specified queue.
Adjust the message body or other properties as needed based on your requirements.

Make sure to handle errors appropriately and ensure that your Azure account has the necessary permissions to send messages to the specified queue in the Service Bus namespace.

This process sets up a basic Azure Service Bus namespace. From there, you can integrate it into your applications, set up messaging patterns, and utilize the Service Bus functionalities to facilitate communication between different components of your applications or services.

Conclusion

Throughout this article, we've covered the creation and receipt of messages within and from a queue.

This service broadens the spectrum of possibilities significantly. One can envision utilizing queues within Azure Functions to trigger processes upon message receipt.

I hope this article has allowed you to familiarize yourself with Azure Service Bus, and please leave a comment if you have any questions.

Mentor tools V: Performance Review

Irene Mateo Herrero — Wed, 17 Jan 2024 16:27:09 +0000

Are you in charge of a colleague's Performance Review? Is it your first time doing it?

If so, I can give you a hand with that. From my experience, I know that sometimes the Performance Review process is not easy, especially the first times you do it. You may feel lost, you may not know where to start, or you may even feel a little nervous about the process. Since I've been through that, I want to give you some tips that have helped me.

But first it would be good to understand what the purpose of the Performance Review process is, right? Let's get to it!

1. What is the Performance Review process?

The Performance Review process is nothing more than the evaluation of a person's performance at work.

If you are reading this now, you are probably in the final phase of this process, that is, preparing the document and the final meeting in which you are going to communicate to your mentee your evaluation of the whole year.

But really the Performance Review is an ongoing, year-long process with some milestones that are probably familiar to you:

Goal Setting meeting
Goals follow-up meetings
Gap analysis meeting

As you will see, you probably have actually been doing performance review throughout the year if you have been working with your mentee for some time and you’ve had several one on ones where you’ve been:

Giving continuous feedback to your mentee on their progress.
Managing their expectations
Periodically aligning their progress with the company's objectives.

If so, this last part of the process (i.e. filling out the annual Performance Review document and the communication meeting), will be a mere formality. So don't panic, you're doing fine!

If you haven't done all this exactly, I encourage you to reflect on your areas of improvement as a mentor in this process - we all have something to improve!

2. My Tips

Here you’ve got some tips to face this last part of the Performance Review process.

I’ll divide the tips in two steps:

Filling-in the Performance Review document
Communication of the Performance Review

Step 1: Fill in the Performance Review document

To fill out the Performance Review document I recommend that you follow these steps:

Collect information & documentation:
- Get feedback from all the people who can provide feedback on your mentee (peer feedback, client feedback, self assessment, etc.).
- Take the documents describing the skills you have to assess for my mentee according to their role and seniority (called Skills dictionaries at our company).
- Review their Performance Review document from last year.
- Take a look at the Job description, i.e. the document where it is specified which skills are attributed to their role and seniority.
- If you still don't have a 360º view of their performance, you can set up a meeting with whomever you need to get a better perspective of their performance, for more objectivity.
Fill-in the Performance Review document, keeping in mind that the idea is to:
- highlight achievements
- point out areas for improvement, justifying them with evidence and focusing on proposing solutions.

Throughout this process, try to be as objective as possible.

And if you need help with anything, don't hesitate to ping to a fellow mentor with more experience, who will surely give you a hand.

Step 2: Communication of the Performance Review

This is a particularly important moment.

Yes, it may only be a formality if there has been continuous feedback throughout the year, but it reminds me a bit of getting my end-of-year grades in high school. So, in some ways, it can be a difficult conversation to deal with.

However, I prefer to see it as a conversation where you can:

Strengthen the trusting relationship you already have with your mentee.
Celebrate achievements and identify what has made your mentee achieve those achievements in order to repeat it.
Detect areas of improvement and decide what can be done about it.
Continue to know better what are the expectations, motivations... of our mentee.
Align the mentee's ambitions with the company's objectives.

Having said that, the difference I see with my teacher giving grades at school is that this is a two-way conversation. The mentor provides an input, which is the Performance Review document and its evaluations, and from there, a dialogue is created with the mentee in which they can also contribute their point of view.

The value of the Performance Review lies not so much in the mentor's notes and comments, but above all in the dialogue that is generated from them.

To make this meeting as fruitful as possible, here are some tips:

Write to your mentee to arrange a date and time that suits you both and you have enough time to talk. This communication only happens once a year, so make it a priority!
Consider sending the Performance Review document in advance to your mentee so that they can look at it calmly and come to the meeting with questions, doubts...
Along with the Performance Review document, this year I have sent a message like this to convey my mindset regarding this meeting, and thus also generate safe space, as I think that sometimes this moment can be a bit imposing and I want my mentee to feel comfortable to give their point of view:

Hello [mentee’s name] ! Here is your PR. I hope, above all, that it will be useful to you. Read it calmly and if you have doubts, at the meeting ask me anything you need, feel free.

I have tried to write a feedback with what I have seen from you this year and with all the information I have received from colleagues, clients and your own self assessment. If you see something that doesn't fit you, feel free to discuss it. For me, the enriching part of the Performance Review meeting is not that I give you the numbers and comments and you read them, but that a fruitful conversation about your professional progress arises from what I have written with more or less success.

Take from the feedback what you can use to improve. In the end, feedback is opinions and there can always be a margin of subjectivity. See you at the meeting!

Block notifications during meeting time. This is the time to activate your active listening at 1000% (and yes, that extra zero is not a typo).
When the meeting starts, remind them that this is a safe space for them to discuss what they need to.
If you have sent them the Performance Review document in advance, ask them what they thought, if they have questions or if they have seen something they want to comment on or disagree with. That's where the discussion can begin. Then, you can ask them if they want to read the document with you again or if it is not necessary.
If you haven't sent the Performance Review before the meeting, ask if they prefer to read it aloud or quietly, or if they prefer you to read it. Also make sure that, if you read it, they feel comfortable interrupting you by saying explicitly, "Feel free to stop me if you want to comment something”.
THIS IS A VERY IMPORTANT TIP: During the meeting, talk to your mentee as if they were someone you love and want to help, for example, your best friend or a younger sibling. Someone you want to care and also help make progress. This will prevent you from falling into criticism and settling into caring, which is crucial when giving feedback to avoid the other person becoming defensive (which is, after all, a normal human reaction to feedback). And when installed in this mood:
- Celebrate their accomplishments: "I'm very proud of your progress in..."
- Point out their areas of improvement with firmness and empathy: "I think you could improve in this area by…, as I have seen that… what do you think?". Remember to argue with evidence and put the focus on possible solutions.
Apply this caring mindset to everything you communicate. It will help you connect with them and strengthen your mentorship relationship.
Encourage them to express their point of view frequently by asking “what do you think about…?” or “How do you see it?”. This will fuel the discussion and, again, make the meeting a safe space from which great insights can emerge.
If there is a point on which your mentee disagrees, discuss it without fear. Keep an open mind, there may be something you have missed in their performance.
If at some point in the discussion the conversation gets complicated, in one of my next articles I will give you tips on how to manage difficult conversations. This is unlikely to happen if you have been giving regular feedback, but it is always a possibility.
Close the conversation by thanking your mentee for their work during the year and their openness in contributing ideas to this meeting.
You can also take the opportunity to ask for feedback on the meeting or even on the whole Performance Review process.
Finally, you can also let them know the next steps in the Performance Review process of your company.

And that's all the advice I can give you! I hope these personal tips will help you face these last steps in the Performance Review process. Good luck and see you in the next one!

Finding a performance issue with React Dev Tools

Alejandro Sánchez Zaragoza — Tue, 02 Jan 2024 15:08:49 +0000

The most efficient way to identify performance issues in our web application is... just using the web platform itself. Trying to analyse every facet of the platform in search of inefficient renderings can be a time-consuming task, and addressing these less critical issues can consume even more time. Therefore, it is crucial to prioritize tackling real problems that significantly impact performance to ensure our efforts are efficiently utilized.

These critical performance problems will appear in a natural way during the application's production usage. It's in this context that you may observe certain actions taking more time than expected. These issues may also arise during the development process, and it is in this case when React Dev Tools, integrated into your browser, become invaluable. It can assist you in pinpointing the origin cause of the problem, facilitating an effective resolution process.

We are going to use the React Developers Tools, and you can download the Chrome extension at this link

To be able to use the Profiler tool the application needs to be running in production mode, so first we have to run a build command with the --profile flag
npm run build -- --profile

After that we can serve the build with
serve -s build

Using profiler to find a performance issue

Having our application served on production mode we can make use of the Chrome dev tools properly. We can open the Chrome console with cmd+opt+j and go to the "profile" tab

In normal use, when you are ready to start recording the performance behaviour on your platform, you can click on the "Start profiling" button and then start making actions.

Finally, when clicking on the "Stop profiling" button we´ll see the result of the profiling with the identifier of each element.

And clicking on each, an explanation of what has triggered the re-render of each react element.

We can feel that something is running slow on our platform. If we see the profiler after the recording, we can check that each keypress an input takes 150ms

We can check on the performance tab a piece of more detailed information, which lets us know that something is happening on a function call triggered on each keydown.

After reviewing the code, we can find that there is an expensive function being called on each render.

We´re passing a direct value as an argument to the useState, which is used as the initial state during every render. This means that the generateRandomColor function is called on every render, potentially leading to unnecessary computations if the function is not memorized or if it performs expensive operations.

In this case, using the function as an argument (() => generateRandomColor()) can be more efficient because it ensures that the initialization is performed only once.

After changing the line 14 to

const [correctAnswer, setCorrectAnswer] = useState(() => generateRandomColor());

We are passing a function as an argument to useState, in this case React treats it as a lazy initializer. This means that the function is only executed once, during the initial render, to determine the initial state value. This can be beneficial if the initialization is computationally expensive or involves asynchronous operations.

After applying those changes to the code and running the performance tab, we can see how the expensive function that was running on each keydown is not there anymore.

Pushing state changes down to solve performance issues

In another example, after running the profiler we can find that there is a component with the suspicious name of "expensive" being rendered on each keypress

After taking a look at the code, we can find that this component is on the app at the same level that some useState hooks, meaning that on each state change, all the react trees of components on this level are going to be re-rendered.

The expensive component is not receiving prop at all, so we can extract all the mutable logic and put it into another component called game.jsx

In this way, we don´t need to touch the expensiveComponent.jsx component, it may contain heavy logic and it´s not needed to refactor it, maybe it´s not even possible. So, putting the logic in this component, we are pushing down the rerenders on the react tree, separating the problem and the changes of the new game.jsx component will not affect the expensive one.

In conclusion, while React Dev Tools offer valuable insights during the development process, particularly in identifying performance bottlenecks, it's important to prioritize issues according to the attention required. By leveraging tools like the Profiler in React Dev Tools, we can detect specific areas of concern and optimize the code according to it. Strategic architectural decisions, such as pushing state changes down the component tree, can easily alleviate unnecessary re-renders and enhance overall application performance.

Thanks for reading! I hope you can use these tips to improve the performance of your application through a combination of tooling, thoughtful design, and focused optimizations.

Build Faster: Your Guide to a Quick-Start Project Template

Alfonso Domenech — Mon, 18 Dec 2023 14:20:47 +0000

Every time I've wanted to embark on a personal project - to learn a new technology or develop an idea - I've found myself redoing configurations for code structure and maintenance, not to mention execution and deployment. It can be frustrating, but I've come to realize that these steps are crucial for success. That's why I'm sharing a minimal template with the most common configurations - the essentials that I believe will help you achieve your goals. We are going to introduce and configure the following technologies.

NestJS
NVM
Commitlint
Husky
Docker
Docker compose
Github Actions

If you want to take a look at it while you read, you can check out the official repo.

NestJS

NestJS is our backend superhero in the template repo. It's like a magic trick for building solid server-side applications effortlessly in TypeScript or JavaScript. Check out more at NestJS Official Website.

Creating .nvmrc file

In this part of the process, the whole team must work with the same version of NodeJS to ensure that all changes made to the application are compatible. This can also be done with Docker, but we will see it later.

In the .nvmrc file we have to put the version of node we want to use.

Then we have to install nvm.

Configure commitlint

If you've worked on projects with a team, you may have noticed that everyone creates different branches and commits changes with random messages. This can make things confusing. That's where commitlint comes in. It helps make sure that commit messages are more consistent and easier to understand.

💡 Here we have to explain the commit convention and if we want to add our custom commit configuration. Also, the benefits of including commitlint in the projects.

Now we have to set up commitment in our project following the instructions of the library commitlint.

First, we must install the library and the convention we want to follow. In our case, we are going to use conventional commits.



npm install --save-dev @commitlint/cli @commitlint/config-conventional

Then we have to configure commitlint to use the conventional config. Let´s create our commitlint.config.js.



module.exports = {
  extends: ['@commitlint/config-conventional'],
};

Set up Husky

Husky is a library which allows developers to execute some commands in the different Git hooks. Why do we want this? As we said we need to ensure a little bit of homogeneity in our project with husky so we can achieve this. Let´s see how.
So, there's this neat library called husky that developers can use. It helps you run specific commands in various Git hooks(https://git-scm.com/docs/githooks), which is a fancy way of saying it keeps your project looking consistent. Why is that a good thing? Well, it makes everything easier to understand! Want to know more? Let me break it down.

First, we need to install husky in our project. For this we are going to follow husky automatic installation which is recommended.



npx husky-init && npm install

This command executes the next actions.

Add the prepare script to package.json.
Create a sample pre-commit hook that you can edit (by default, npm test will run when you commit).
Configure Git hooks path.

If you want manual installation and customize the husky configuration you can read the corresponding documentation.

Now we have to configure husky to execute some commands in the git hooks. We are going to add three that from my point of view are the most important.

To add a new hook we have to follow the next structure.



npx husky add .husky/{gitHook} "{command}"

This command is going to create different bash files in the .husky directory. The names of these files are going to be named with the correspondent git hook.

The first one is the commit-msg hook. Here we are going to ensure that our commit messages follow our commitlint configuration.

So, let´s add our new hook! Following the command structure mentioned above.



npx husky add .husky/commit-msg  'npx --no -- commitlint --edit ${1}'

The second one is the pre-commit hook. With this hook, we are going to lint and format the files we want to add to our commit. This action is executed before committing our changes.



npx husky add .husky/pre-commit  'npm run lint && npm run format'

The last one but not the least, is the pre-push hook. This hook is going to execute our test before pushing our changes.



npx husky add .husky/pre-push  'npm run test'

Docker

Now we want to create our development environment for our NestJS project. In this part of the article we are going to see how to include Docker and Docker compose.

First, we need to configure our Docker container creating our Dockerfile.

Our Dockerfile employs multi-stage builds, which facilitate the setup of our docker container for both local and development settings. This method offers a range of advantages. It's a two-step process, compile dependencies in one stage and then keep only the essentials in the final image improving our Docker image performance. To learn more about multi-stage builds you can check the official documentation



# BUILD FOR LOCAL DEVELOPMENT

FROM node:20-alpine As development

# Create app directory
WORKDIR /usr/src/app

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure copying both package.json AND package-lock.json (when available).
# Copying this first prevents re-running npm install on every code change.
COPY --chown=node:node package*.json ./

# Install app dependencies using the `npm ci` command instead of `npm install`
RUN npm ci

# Bundle app source
COPY --chown=node:node . .

# Use the node user from the image (instead of the root user)
USER node

# BUILD FOR PRODUCTION

FROM node:20-alpine As build

WORKDIR /usr/src/app

COPY --chown=node:node package*.json ./

# To run `npm run build` we need access to the Nest CLI which is a dev dependency. In the previous development stage we ran `npm ci` which installed all dependencies, so we can copy over the node_modules directory from the development image
COPY --chown=node:node --from=development /usr/src/app/node_modules ./node_modules

COPY --chown=node:node . .

# Run the build command which creates the production bundle
RUN npm run build

# Set NODE_ENV environment variable
ENV NODE_ENV production

# Remove husky from the production build and install the production dependencies
RUN npm pkg delete scripts.prepare \
    npm ci --omit=dev

USER node

# PRODUCTION

FROM node:20-alpine As production

# Copy the bundled code from the build stage to the production image
COPY --chown=node:node --from=build /usr/src/app/node_modules ./node_modules
COPY --chown=node:node --from=build /usr/src/app/dist ./dist

# Start the server using the production build
CMD [ "node", "dist/main.js" ]

Docker-compose configuration

Docker-compose is our dev sidekick, making local coding a cakewalk. One config file and that´s it! No more "it works on my machine" drama. Our docker-compose file is located at the root level of our project.



services:
  api:
    build:
      dockerfile: Dockerfile
      context: .
      # Only will build development stage from our dockerfile
      target: development
    volumes:
      - .:/usr/src/app
    env_file:
    - .env
    # Run a command against the development stage of the image
    command: npm run start:dev
    ports:
      - 3000:3000

Now it's a piece of cake to develop our app with the container system we have. It's super easy and hassle-free.

Github Action

Continuous Integration (CI) is a software development practice that allows developers to automatically build, test, and validate their code changes in a centralized and consistent environment. GitHub Actions is a powerful CI/CD (Continuous Integration/Continuous Deployment) platform integrated directly into GitHub repositories, enabling developers to automate their workflows seamlessly. Checkout their documentation to learn more!

In this section, I'll guide you through the process of setting up a basic CI pipeline using GitHub Actions. This pipeline will automatically build and push your docker image to the Docker Hub account when a Pull Request is merged.

Great! So, to push our Docker images, we need to authenticate our GitHub action. Don't worry, it's quite simple. First, let's add your Dockerhub username and token. After that, we just need to store the credentials in our GitHub repository settings. You can see how to do this in the image below. Let me know if you need any help with this.

Awesome! Let's create our workflow now. We need to place it in the root of your directory at .github/workflows/build.yml. This file will help us set up our CI steps. Don't worry, I'll guide you through the different steps so you can easily follow along!



# This workflow is triggered when a pull request is closed (merged or closed without merging) into the main branch.
on:
  pull_request:
    branches: [main]
    types: [closed]
jobs:
  #This defines a job named "build" that runs on the latest version of the Ubuntu environment.
  build:
    name: Build Docker image
    runs-on: ubuntu-latest
    steps:
      - # This step checks out your Git repository content
        name: Checkout
        uses: actions/checkout@v4

      - # Uses the docker/login-action to log in to Docker Hub using the provided username and token.
        # The credentials are stored as secrets (DOCKERHUB_USERNAME and DOCKERHUB_TOKEN).
        name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - # Extracts the repository name from the GitHub repository full name and sets it as an environment variable (REPO_NAME). 
        # This information can be useful for later steps.
        name: Get repository name
        run: |
          repo_full_name="$GITHUB_REPOSITORY"
          IFS='/' read -ra repo_parts <<< "$repo_full_name"
          echo "REPO_NAME=${repo_parts[1]}" >> $GITHUB_ENV

      - # Uses the docker/metadata-action to extract metadata such as tags and labels for Docker. 
        # This metadata can be used for versioning and labelling Docker images.
        name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: |
            ${{ secrets.DOCKERHUB_USERNAME }}/${{env.REPO_NAME}}
          tags: |
            type=sha,format=short 

      - # Uses the docker/build-push-action to build and push the Docker image. It specifies the context as the current directory (.), the Dockerfile location (./Dockerfile), tags from the metadata, and labels from the metadata. 
        # The push: true indicates that the image should be pushed to the Docker Hub registry.
        name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          file: ./Dockerfile
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          push: true

Now each time we merge our PRs a GitHub action is going to build a docker image and push it to our registry in DockerHub as you can see in the following images.

Hope you found it cool and picked up something useful. Stay curious, keep learning, and rock on! Cheers to your next adventure!

Bibliography

Semantic Search with Elasticsearch on Large Documents

Lövei Róbert — Wed, 15 Nov 2023 13:51:48 +0000

Semantic search is a technique used by search engines to improve the accuracy of search results by understanding the intent and contextual meaning of the words used in a search query. Traditional search engines primarily rely on keyword matching to retrieve results. However, semantic search goes beyond matching keywords and takes into account the relationship between words, the context of the search, and the user's intent to deliver more relevant results. What if we combine both with a search engine?

Elasticsearch introduced the dense_vector field type in late 2020, which stores dense vectors of float values. So how does this support semantic search?

In the context of semantic search and natural language processing, vectors are mathematical representations of words or phrases in a high-dimensional space. These representations capture the semantic meaning of words or phrases based on their context and relationships with other words in a given dataset. Vectors are part of a mathematical technique known as word embeddings or word vectors.

1. Prepare Documents to Transformation into Embeddings

There are several ways of transforming our documents into embeddings. One is to use an external API, like OpenAI’s, or Microsoft Azure’s embedding endpoints. Another way is to use our local computer, or an on-premises server with a Hugging Face model, like bge-large-en.

Either way, we will face a document size limitation in the transformation step. In the case of OpenAI’s text-embedding-ada-002 model, the limit is 8192 tokens, which is roughly 5000 words. In the case of Hugging Face models, the token size limitation in most cases is 512, which is around 312 words. What can we do to overcome these limits?

First, we need to slice our documents to make them fit into token limits with the right tool. At One Beyond, we use CharacterTextSplitter class from Python’s langchain library.

text = "..." # your text 
from langchain.text_splitter import CharacterTextSplitter 
text_splitter = CharacterTextSplitter( 
separator = ".", 
chunk_size = 512, 
chunk_overlap = 256 
) 

docs = text_splitter.create_documents([text])

In this example our separator is a “.” punctuation sign, which means we split at sentence endings. We allow 512 characters in one chunk, but with 256 characters overlap from the last and next chunks. We need the overlap to keep the context of a specific chunk. If you want to read about other chunking solutions this is the right article for you.

2. Transform a Single Text into Multiple Embeddings

At this step we have our original documents and the chunked versions of them, which fit into the limitations of our selected model.

from sentence_transformers import SentenceTransformer 
model = SentenceTransformer('BAAI/bge-large-en-v1.5') 

text = "..." # your text 
document_chunks = text_splitter.create_documents([text]) 
texts = [doc.page_content for doc in document_chunks] 
texts = [text.replace("\n", ". ") for text in texts] 

embeddings = model.encode(texts)

In this example we use SentenceTransformer class to load model BGE Large and use it to tokenize our chunks.

The other options are to use either OpenAI, or Azure AI API to embed them. Here is an example with Azure:

import openai 
from dotenv import load_dotenv 

load_dotenv() 

openai.api_key = os.getenv("AZURE_AI_KEY") 
openai.api_base = "https://ob-openai-semantic-search-eastus.openai.azure.com/" 
openai.api_type = 'azure' 
openai.api_version = '2023-05-15' 

your_text = "..." # your text 

document_chunks = text_splitter.create_documents([your_text]) 
texts = [doc.page_content for doc in document_chunks] 
texts = [text.replace("\n", ". ") for text in texts] 
embeddings = [] 
for text in texts: 
    response = openai.Embedding.create(engine="text-embedding-ada-002", input=text) 
    embeddings.append(response.data[0].embedding)

We can configure openai python lib to user either OpenAI, or Azure endpoints.

3. Create Elasticsearch schema and insert documents

Since we have our original long text and multiple chunks and embeddings associated with it, we need to create parent child relationship between them in our Elasticsearch index. There is an example payload below how you can create such an index.

{ 
  "mappings": { 
    "properties": { 
      "id": {"type": "keyword", "store": "true"}, 
      "text": {"type": "text", "store": "true"}, 
      "embedding_bge_large_en_v1_5": { 
        "type": "dense_vector", 
        "dims": 512, 
        "index": True, 
        "similarity": "cosine", 
      }, 
      "vectors": { 
        "type": "join", 
        "relations": { 
          "chunk_embedding": "embedding_bge_large_en_v1_5", 
        }, 
      } 
    } 
  } 
}

As we can see, we define the document property embedding_bge_large_en_v1_5 as dense_vector with 512 lengths. We define cosine as similarity type. Cosine similarity is a method to determine distance between vectors. If you want to know more about it this is a useful article. Below is an example of insert document payload into this index.

{ 
  "id": f"{text['id']}_{vector_index}", 
  "embedding_bge_large_en_v1_5": vector, 
  "vectors": { 
    "name": "embedding_bge_large_en_v1_5", 
    "parent": text['id'] 
  }, 
  "routing": 1 
}

4. Search in the index

At this point we have our index populated with data. It is time to run semantic search on it.

As we can see above, we transform our user search into an embedding in similar way to the one I detailed it in Point 2, except that we will have only 1 embedding without chunking this time.

We compare this embedding with cosine similarity to the chunk embeddings we store in Elasticsearch. This is a built-in feature, so we can do it with a simple query as detailed below.

{ 
  "size": 10, 
  "_source": ["text"], 
  "query": { 
  "has_child": { 
    "score_mode": "max", 
    "type": "embedding_bge_large_en_v1_5", 
      "query": { 
        "function_score": { 
          "script_score": { 
            "script": { 
              "source": "(cosineSimilarity(params.vector,'embedding_bge_large_en_v1_5') + 1)", 
              "params": {"vector": query_vector.tolist()}, 
            } 
          } 
        } 
      } 
    } 
  } 
}

Earlier, we defined cosine as similarity on the child field’s similarity type, so we don’t need to tell Elastic in the query to use it. In the example, query_vector is the search embed passed in as vector to proceed similarity search. The parent document’s score will be the maximum similarity score of its children.

5. Example

A good example for all the above is when we have written transcriptions of knowledge sharing sessions or other kind of presentations and we want to build a search bot. Usually presentation or knowledge sharing transcriptions are way longer than embedding limitations with a few hundred words. With the method I explained above you’ll be able to run searches on your knowledge base like “Show presentations about user interface development”. Here is a real example answer from our knowledge sharing bot on our company Slack:

Semantic search is a powerful information retrieval technique that goes beyond traditional keyword matching to understand the meaning and context of user queries. In the context of searching for UI development presentations, semantic search can enhance the search experience by considering the underlying concepts and relationships between words.

For instance, this query was focused on UI development, but semantic search algorithms can recognize related terms like "user experience (UX)" even if not explicitly mentioned in the query. This enables the system to retrieve presentations that may be relevant to UX, ensuring a more comprehensive and accurate set of results. In essence, semantic search helps bridge the gap between user intent and search results by intelligently interpreting the meaning behind the words used in the query.

Integrate MongoDB database with multiple collections using Mongoose in NestJS and Typescript

Elizabeth Morillo — Wed, 25 Oct 2023 13:56:12 +0000

In this article we are going to show you a way to integrate multiple MongoDB(NoSQL database) collections using Mongoose for highly scalable projects into the NestJS framework.

What are we going to need?

MongoDB database, you can use one locally or use the cloud MongoDB database.
Have a new project created with Nest CLI, you can check this article for first steps.

Installation:

Before starting with our code, it is necessary to install all the dependencies that we need, to do this in our console we run
npm install @nestjs/mongoose mongoose

Mongoose Schema

Before connecting and configuring our database we are going to create the necessary schemas. Each Schema represents a MongoDB collection that will define our models and each key will define a property in our document that will be associated with a type.
If you want to read more about it, I recommend this official guide.

In the root of our project, we are going to create the following folder structure and inside our Schema folder let’s create a file for each collection we have in our database, in my case I will have only two, it should be something like this:

src
├── api 
│   ├── database  
│       └── schemas 
│         └── user.schema.ts 
│         └── dog.schema.ts

Now let's define our schemas:

// schemas/user.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { HydratedDocument } from 'mongoose';

export type UserDocument = HydratedDocument<User>;

@Schema()
export class User {
  @Prop({ required: true, unique: true })
  id: number;

  @Prop({ required: true })
  first_name: string;

  @Prop({ required: true })
  last_name: string;

  @Prop({ required: true })
  email: string;
}

export const UserSchema = SchemaFactory.createForClass(User);

// schemas/dog.schema.ts

import * as mongoose from 'mongoose';
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { HydratedDocument } from 'mongoose';
import { User } from './user.schema';

export type DogDocument = HydratedDocument<Dog>;

@Schema()
export class Dog {
  @Prop()
  name: string;

  @Prop()
  age: number;

  @Prop()
  breed: string;

  @Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'User' })
  owner: User;
}

export const DogSchema = SchemaFactory.createForClass(Dog);

This looks spectacular! and we can use decorators to improve our code. The @Prop() decorator defines schema types that are automatically inferred by Typescript.
I personally prefer to use decorators since it allows us a better definition, we can send arguments and improve the typing to ensure that we do not have any errors in the future related to the data we send to our database, but if you prefer you can also create your schematics manually, Here's an example:

export const DogSchema = new mongoose.Schema({ 
  name: String, 
  breed: String, 
  age: Number, 
  owner: {type: mongoose.Types.ObjectId, ref: "User"} 
});

HINT: Remember we don’t need to add an _id since Mongoose automatically adds an _id property to your schema.

Connection and Database Module

Once our models have been defined, we can create the connection to our database, inside the folder we created earlier called database, we are going to create a file named database.module.ts where we will make the connection to our database.

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import database from '../constants/database';

@Module({
  imports: [
    MongooseModule.forRoot('<YOUR_MONGODB_CONNECTION_STRING>', {
      dbName: database.DATABASE_NAME,
    }),
  ],
  controllers: [],
  providers: [],
})
export class DatabaseModule {}

HINT: It is important to indicate the name of the database to which we want to connect (dbName)

Following best practices, you should create a folder named constants, where we will keep all these literal numeric or string values, known as "magic numbers" and "magic strings", In my case I have only created a database file, here is an example:

// ../api/constants/database.ts

export default {
  DATABASE_NAME: 'dev_test',
};

There is also the possibility of creating our database connection asynchronously and for this Nest provides us with a method called forRootAsync(), this method also allows us to pass options asynchronously and inject dependencies as a ConfigModule, for example, this will be the same connection but asynchronously:

@Module({
  imports: [
    MongooseModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        uri: configService.get<string>('<YOUR_MONGODB_CONNECTION_STRING>'),
        dbName: database.DATABASE_NAME,
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [],
  providers: [],
})
export class DatabaseModule {}

If you want to know more about how to configure and use a ConfigModule and a ConfigService using the environment variables, I recommend this article.

To be able to use the new connection we need to import the new DatabaseModule to our app.module

import { Module } from '@nestjs/common';
import { DogModule } from './api/dog/dog.module';
import { UserModule } from './api/user/user.module';
import { DatabaseModule } from './api/database/database.module';

@Module({
  imports: [DogModule, UserModule, DatabaseModule],
  controllers: [],
  providers: [],
})
export class AppModule {}

Using our collections

Up to this point if we have our app running and listening to all the changes we have been making (npm run start:dev) we should not have any errors in the console, Excellent!

Now let's see how to consume our data stored in both collections independently. To begin we are going to create the following folders

src
├── api 
│   ├── database
│   ├── dog
│       └── dog.module.ts
│       └── dog.service.ts
│   ├── user
│       └── user.module.ts
│       └── user.service.ts

In this example I only need two modules, but the idea is that you create how many modules you need according to your collections.

It’s important in this step that if we have multiple collections, we should always indicate the name of the schema to which we want to refer, the method forFeature() provided by the MongooseModule allow us to configure the module, the models by including them should be registered in the current scope.

// dog.module.ts

import { Module } from '@nestjs/common';
import { DogService } from './dog.service';
import { DogController } from './dog.controller';
import { MongooseModule } from '@nestjs/mongoose';
import { Dog, DogSchema } from 'src/api/database/schemas/dog.schema';

@Module({
  imports: [MongooseModule.forFeature([{ name: Dog.name, schema: DogSchema }])],
  controllers: [DogController],
  providers: [DogService],
})
export class DogModule {}

// user.module.ts

import { Module } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { MongooseModule } from '@nestjs/mongoose';
import { User, UserSchema } from 'src/api/database/schemas/user.schema';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
  ],
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

NOTE: Remember to Add your modules to app.module.ts in the imports

Now we are ready for the queries!

As you can see, both models are practically the same, the only difference is that they use different collections, having registered our schema allows us to inject using the @InjectModel() decorator in the service that we want to use

// dog.service.ts

import { Injectable, Logger } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Dog } from 'src/api/database/schemas/dog.schema';

@Injectable()
export class DogService {
  constructor(@InjectModel(Dog.name) private dogModel: Model<Dog>) {}

  async findAll(): Promise<Dog[]> {
    Logger.log('This action returns all DOGS');
    return this.dogModel.find();
  }
}

Amazing, isn't it? This will not only allow us to have a more organized project but thinking about the future when refactoring/deleting/adding collections will be much easier.

Now wait a moment, what would happen if, for example, our dog service also needed to use data from the User’s collection? Would it be possible to add a second collection to the dog module? Yes, it is possible!

Keep in mind that for these cases it is always better to create fields that make references between the collections, this is an example of how we would inject the user collection into our Dog module:

// dog.module.ts

import { Module } from '@nestjs/common';
import { DogService } from './dog.service';
import { DogController } from './dog.controller';
import { MongooseModule } from '@nestjs/mongoose';
import { Dog, DogSchema } from 'src/api/database/schemas/dog.schema';
import { User, UserSchema } from '../database/schemas/user.schema';

@Module({
  imports: [
    MongooseModule.forFeature([
      { name: Dog.name, schema: DogSchema },
      { name: User.name, schema: UserSchema },
    ]),
  ],
  controllers: [DogController],
  providers: [DogService],
})
export class DogModule {}

// dog.service.ts

import { Injectable, Logger } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Dog } from 'src/api/database/schemas/dog.schema';
import { User } from '../database/schemas/user.schema';

@Injectable()
export class DogService {
  constructor(
    @InjectModel(Dog.name) private dogModel: Model<Dog>,
    @InjectModel(User.name) private readonly userModel: Model<User>,
  ) {}

  async findAll(): Promise<Dog[]> {
    Logger.log('This action returns all DOGS');
    return this.dogModel.find();
  }

  async findAllUsers(): Promise<User[]> {
    Logger.log('This action returns all USERS in dog service');
    return this.userModel.find();
  }
}

Thank you all very much for reading this article and I hope it helps you create amazing applications. Please let me know in the comments what you think about this post or if you have any questions. Thank you so much for reading!

Thank you all and happy coding! 🖖

Forem: One Beyond

Deploying a React + Vite SPA to a Private S3 Bucket with CloudFront and OAC

1. Understanding How OAC, CloudFront, and S3 Work Together

What is Origin Access Control (OAC)?

How CloudFront Works with S3 and OAC

2. Setting Up the S3 Bucket

Terraform Configuration:

3. Creating a CloudFront Distribution with Custom Error Handling

Why Use custom_error_response?

Terraform Configuration:

4. Why Use Vite Instead of Webpack?

Advantages of Vite

5. When to Use This Approach vs. Other Alternatives

Use This Approach When:

Consider Other Options When:

6. Configuring Vite for Correct Asset Paths

Why the base Option in vite.config.js?

Why Use base: '/'?

7. Deploying with GitHub Actions

Conclusion

Stress Management

Know your patterns

Stress Awareness

Mentor tools VII - Set up goals

Step 1: Ask, ask, ask

Step 2: Write down the goals

Mentor tools VI: First 1:1

Before the 1:1

During the 1:1

Azure Service Bus 101: Introduction to Queues and Messaging

Introduction

Azure Service Bus — Overview

Azure Service Bus — Queues

Azure Service Bus — Topics

In practice?

Conclusion

Mentor tools V: Performance Review

Finding a performance issue with React Dev Tools

Using profiler to find a performance issue

Pushing state changes down to solve performance issues

Build Faster: Your Guide to a Quick-Start Project Template

NestJS

Creating .nvmrc file

Configure commitlint

Set up Husky

Docker

Docker-compose configuration

Github Action

Bibliography

Semantic Search with Elasticsearch on Large Documents

1. Prepare Documents to Transformation into Embeddings

2. Transform a Single Text into Multiple Embeddings

3. Create Elasticsearch schema and insert documents

4. Search in the index

5. Example

Integrate MongoDB database with multiple collections using Mongoose in NestJS and Typescript

What are we going to need?

Installation:

Mongoose Schema

Connection and Database Module

Using our collections

Why Use `custom_error_response`?

Why the `base` Option in `vite.config.js`?

Why Use `base: '/'`?