TILs - Fueling Curiosity, One Insight at a Time

At Codemancers, we believe every day is an opportunity to grow. This section is where our team shares bite-sized discoveries, technical breakthroughs and fascinating nuggets of wisdom we've stumbled upon in our work.

Published
Author
user-image
Soniya Rayabagi
Handling Terraform State Errors with S3 Backend:
We use an S3 bucket to store our Terraform state. If Terraform fails to update the state, it creates an errored.tfstate file in your working directory. Reapplying will cause errors because the resources already exist.
To fix this, push the errored state back to S3:
terraform state push errored.tfstate

#devops #terraformstateS3 #errorhandling
Published
Author
user-image
Syed Sibtain
System Analyst
In Ruby, exception handling is done using begin, rescue, ensure, and end blocks. Here's a brief overview of how they work in a general Ruby context:


Ruby

begin
  # Code that might raise an exception
rescue SomeExceptionClass => e
  # Code that handles the exception
ensure
  # Code that will always run, regardless of whether an exception was raised
end


begin: Marks the beginning of a block of code that might raise exceptions.

rescue: Specifies what to do if a specific exception is raised. We can rescue multiple exception types by chaining rescue blocks.

ensure: An optional block that will always execute, regardless of whether an exception was raised or rescued. It's useful for cleanup code that must run no matter what.

#ruby #rails
Published
Author
user-image
Syed Sibtain
System Analyst
Using Ruby's built-in URI::MailTo::EMAIL_REGEXP for email validation is generally better than using a custom regular expression due to its robustness, reliability, and maintenance by the Ruby core team.

Ruby

class User < ApplicationRecord
  has_secure_password
  validates :name, presence: true

  # Using a custom regular expression for email validation
  validates :email, presence: true, format: { with: /\A[^@\s]+@[^@\s]+\z/ }, uniqueness: true
  
  # Using Ruby's built-in URI::MailTo::EMAIL_REGEXP for email validation
  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }, uniqueness: true

end


#ruby #regex #rails
Published
Author
user-image
Syed Sibtain
System Analyst
Fixing Image Rendering in Rails with Active Storage
How to fix the error PG::UndefinedTable: ERROR: relation "active_storage_attachments" does not exist

This error occurs because Active Storage in Rails relies on specific database tables (e.g., active_storage_attachments and active_storage_blobs) to store metadata about attached files. If these tables do not exist, Rails cannot store or retrieve the necessary metadata for file attachments, resulting in the mentioned error.

By following these steps, we ensure that the necessary Active Storage tables are created, allowing Rails to store and retrieve image metadata correctly.

Run Active Storage Installation:

Ruby

rails active_storage:install


Migrate the Database:

Code

rails db:migrate


Restart the Rails Server:

Code

rails server


Then in views we can simply use the helper and render the image

Code

<%= image_tag url_for(recipe.image), class: "w-full h-64 object-cover" %>


#rails #activestorage
Published
Author
user-image
Soniya Rayabagi
Terraform Import :
terraform import allows you to bring existing resources into Terraform's state management without recreating them.
Syntax: terraform import <RESOURCE_TYPE>.<RESOURCE_NAME> <RESOURCE_ID>
Example: terraform import aws_s3_bucket.bucket my-existing-bucket

#devops #TerraformImport
Published
Author
user-image
Adithya Hebbar
System Analyst
To create a dump of all the inserts with data and column names using pg_dump

Code

pg_dump -U your_username -d your_database -h your_host -p your_port --column-inserts --data-only -f output.sql


#postgres #database
Published
Author
user-image
Sujay
To set the autoincrement number in PostgreSQL, use the following query:

Code

ALTER SEQUENCE "users_id_seq" RESTART WITH 1000;


#database #postgresql
Published
Author
user-image
Soniya Rayabagi
Automating Terraform with GitHub Actions:
I learned how to automate Terraform linting, planning, and applying using GitHub Actions. This helps ensure code is always in good shape and deployed correctly. Here’s a step-by-step guide to set it up:
Steps:
• Create a .github/workflows/terraform.yml file in your repository. This single file defines the entire workflow for GitHub Actions.
• Set up the workflow to trigger on pull requests and pushes to the main branch. This ensures that the Terraform configuration is checked and applied automatically whenever changes are made.

Code

name: Terraform CI/CD

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  terraform:
    name: Terraform Lint, Plan, and Apply
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

    - name: Set up Terraform
      uses: hashicorp/setup-terraform@v2
      with:
        terraform_version: 1.8.3

    - name: Terraform Init
      run: terraform init

    - name: Terraform Format
      run: terraform fmt -check

    - name: Terraform Validate
      run: terraform validate

    - name: Terraform Plan
      run: terraform plan

    - name: Terraform Apply
      run: terraform apply -auto-approve
      env:
        TF_VAR_user: ${{ secrets.TF_VAR_USER }}


• Single Workflow File : By using a single .github/workflows/terraform.yml file, I streamline the CI/CD process, making it easier to manage and maintain.
• Checkout Repository : The actions/checkout@v2 step checks out the repository so that the workflow has access to the Terraform configuration files.
• Set up Terraform : The hashicorp/setup-terraform@v2 action sets up the specified version of Terraform on the runner.
• Terraform Init: The terraform init command initializes the working directory containing Terraform configuration files.
• Terraform Format : The terraform fmt -check command ensures that the Terraform configuration files are properly formatted. This helps maintain a consistent coding style.
• Terraform Validate : The terraform validate command checks the syntax and configuration of the Terraform files to ensure they are valid.
• Terraform Plan : The terraform plan command creates an execution plan, showing what actions Terraform will take to reach the desired state. This step allows you to review changes before they are applied.
• Terraform Apply : The terraform apply -auto-approve command applies the changes required to reach the desired state of the configuration.
#devops #Terraform #GitHubActions #HashiCorp
Published
Author
user-image
Vaibhav Yadav
Senior System Analyst
When implementing password and confirmPassword field with react-hook-form and zod for validation, you might need to figure out a way to run the validation for both the fields simultaneously. With the default approach, or the simple implementation you would notice that upon updating password field, the validation for confirm password won't kick in and vice versa.

One solution for these would be to use Controller from react-hook-form and use superRefine to run your validation simultaneously.

Snippet:

Code

// validation Schema
import { z } from 'zod';

// Define the schema
const schema = z.object({
  password: z.string().min(8, 'Password should be at least 8 characters long'),
  confirmPassword: z.string().min(8, 'Password should be at least 8 characters long'),
}).superRefine((data, ctx) => {
  if (data.password !== data.confirmPassword) {
    ctx.addIssue({
      code: 'custom',
      path: ['confirmPassword'],
      message: 'Passwords do not match',
    });
  }
});

export default schema;



Code

// form component
import React from 'react';
import { useForm, Controller } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import schema from './schema'; // Import the schema

const PasswordForm = () => {
  const { handleSubmit, control, formState: { errors } } = useForm({
    resolver: zodResolver(schema),
  });

  const onSubmit = (data) => {
    console.log('Form Data:', data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <div>
        <label>Password</label>
        <Controller
          name="password"
          control={control}
          render={({ field }) => (
            <input
              type="password"
              {...field}
              placeholder="Enter your password"
            />
          )}
        />
        {errors.password && <span>{errors.password.message}</span>}
      </div>

      <div>
        <label>Confirm Password</label>
        <Controller
          name="confirmPassword"
          control={control}
          render={({ field }) => (
            <input
              type="password"
              {...field}
              placeholder="Confirm your password"
            />
          )}
        />
        {errors.confirmPassword && <span>{errors.confirmPassword.message}</span>}
      </div>

      <button type="submit">Submit</button>
    </form>
  );
};

export default PasswordForm;


Second solution, just in case if you're not using the react-hook-form's Controller would be using the trigger and touchedFields from react-hook-form and using react's classic useEffect:


Code

// component with Schema
import React, { useEffect } from 'react';
import { useForm } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';

const schema = z.object({
  password: z.string().min(8, 'Password should be at least 8 characters long'),
  confirmPassword: z.string().min(8, 'Password should be at least 8 characters long'),
}).superRefine((data, ctx) => {
  if (data.password !== data.confirmPassword) {
    ctx.addIssue({
      code: 'custom',
      path: ['confirmPassword'],
      message: 'Passwords do not match',
    });
  }
});

const PasswordForm = () => {
  const { handleSubmit, register, trigger, formState: { errors, touchedFields } } = useForm({
    resolver: zodResolver(schema),
  });

  const onSubmit = (data) => {
    console.log('Form Data:', data);
  };

  useEffect(() => {
    if (touchedFields.password) {
      trigger('password');
    }
  }, [trigger, touchedFields.password]);

  useEffect(() => {
    if (touchedFields.confirmPassword) {
      trigger('confirmPassword');
    }
  }, [trigger, touchedFields.confirmPassword]);

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <div>
        <label>Password</label>
        <input
          type="password"
          {...register('password')}
          placeholder="Enter your password"
        />
        {errors.password && <span>{errors.password.message}</span>}
      </div>

      <div>
        <label>Confirm Password</label>
        <input
          type="password"
          {...register('confirmPassword')}
          placeholder="Confirm your password"
        />
        {errors.confirmPassword && <span>{errors.confirmPassword.message}</span>}
      </div>

      <button type="submit">Submit</button>
    </form>
  );
};

export default PasswordForm;


Happy Coding!!! 🙂

#reactHookForm #react #formValidation #zod #useEffect
Published
Author
user-image
Soniya Rayabagi
To connect to the PostgreSQL RDS instance using psql:

Code

psql -h ${postgres_host} -U "${postgres_username}" -d ${postgres_database} -W


where, ${postgres_host}: variable representing the PostgreSQL host or db endpoint

#devops #PostgreSQLConnection #rds

Showing page 20 of 83

Your competitors are already using AI.
The question is how fast you want to unlock the value.

Don't know where to start?

AI is everywhere but it's unclear which investments will actually move your metrics and which are expensive experiments.

Your data isn't ready

Most AI projects fail at the data layer. Pipelines, quality, access all need work before LLMs can deliver value.

Internal teams are stretched

Your engineers are shipping product. They don't have capacity to also become AI specialists with production-grade experience.

Legacy systems block everything

Aging, undocumented codebases make AI integration slow, risky, and expensive. They need to move first.

Don't worry. We've got you covered.

Start with the audit.

Book a free discovery call →