Fueling Curiosity, One Insight at a Time

kubectl get ds -n <namespace>

kubectl rollout restart ds <name-of-the-daemon-set> -n <namespace>

:root {
  /* ----- fallback value ----- */
  --primary-color: #3498db;
}

h1 {
  color: var(--primary-color);
}

const App = () => {
  const primaryColor = process.env.NAME === 'a' ? '#fff' : '#000';

  return (
    <div style={{ '--primary-color': primaryColor }}>
      <h1>Hello, World!</h1>
    </div>
  );
};

name: Example Workflow

on:
  workflow_dispatch:
    inputs:
      environment:
        description: 'Select the environment'
        required: true
        default: 'sandbox'
        type: choice
        options:
          - sandbox
          - uat
          - production

jobs:
  example_job:
    runs-on: ubuntu-latest
    steps:
      - name: Display Inputs
        run: |
          echo "Environment: ${{ github.event.inputs.environment }}"

npm i -D prisma-erd-generator @mermaid-js/mermaid-cli
# or
yarn add -D prisma-erd-generator @mermaid-js/mermaid-cli

generator erd {
  provider = "prisma-erd-generator"
}

npx prisma generate

interface User {
    name: string;
    age?: number; // Optional
}

const user1: User = { name: "Joe Mama" }; // Age is optional
const user2: User = { name: "Tony", age: 30 };

console.log(user1); // Output: { name: "Joe Mama" }
console.log(user2); // Output: { name: "Tony", age: 30 }

interface User {
    id: number;
    name: string;
    email: string;
}

function displayUser(user: Partial<User>) {
    console.log(user);
}

displayuser({ name: "Joe Mama" }); // Partial<T> will make the properties optional hence this is valid

class Author < ApplicationRecord 
  has_many :books 
 end

class Book < ApplicationRecord 
  belongs_to :author 
end

# Fetching all authors and their books 
authors = Author.all 

authors.each do |author| 
  puts author.books.pluck(:title) 
end

# Fetching all authors and their books with eager loading 
authors = Author.includes(:books) 

authors.each do |author| 
  puts author.books.pluck(:title) 
end

# Fetching all authors and their books with eager loading using JOIN 
authors = Author.eager_load(:books) 

authors.each do |author| 
  puts author.books.pluck(:title) 
end

# Fetching all authors and their books with eager loading using separate queries 
authors = Author.preload(:books) 

authors.each do |author| 
  puts author.books.pluck(:title) 
end

class Book < ApplicationRecord 
  belongs_to :author 
  scope :published, -> { where(published: true) } 
end

class Author < ApplicationRecord 
  has_many :books 
  has_many :published_books, -> { published }, class_name: 'Book' 
end

@authors_with_published_books = Author.joins(:published_books).select('authors.*, books.title as book_title')

class User < ActiveRecord::Base
  has_many :posts
end

class Post < ActiveRecord::Base
  belongs_to :user
end

user = User.first
user.posts

class User < ActiveRecord::Base
  has_many :posts
end

class Post < ActiveRecord::Base
  belongs_to :user

  scope :published, -> { where(published: true) }
end

user = User.first
user.posts.published

class User < ActiveRecord::Base
  has_many :posts, -> { published }
  has_many :not_published_posts, -> { not_published }
end

class Post < ActiveRecord::Base
  belongs_to :user

  scope :published, -> { where(published: true) }
  scope :not_published, -> { where(published: false) }
end

user = User.first
user.posts # only published posts here

def index
  @people = Person.all

  respond_to do |format|
    format.json { render json: @people}
    format.xml { render xml: @people }
    format.html { render :index}
  end
end

def index
  @people = Person.all
  respond_to :json, :xml, :html  
end

user = User.first
user1 = user.dup
user1:
<User id: nil, name: "Rails">

user = User.first
user1 = user.clone
<User id: 1, name: "Rails">