DEV Community: Aqib Nawaz

Master Claude Code: Setup, Features, Workflows, and Best Practices

Aqib Nawaz — Fri, 19 Jun 2026 13:30:24 +0000

The Complete Guide to AI-Powered Development in Your Terminal

The way developers work is changing. Gone are the days of context-switching between your IDE and ChatGPT. Claude Code brings AI-powered development assistance directly to your terminal, letting you delegate coding tasks to an intelligent assistant without leaving your workflow.

Whether you're automating repetitive tasks, debugging complex issues, or scaffolding new features, Claude Code transforms how you approach development. Let's explore what it is, how to set it up, and how to leverage it effectively.

What is Claude Code?

Claude Code is a command-line tool that lets you delegate coding tasks to Claude, an advanced AI assistant built by Anthropic. Instead of manually writing code or copying code snippets, you describe what you need, and Claude handles the implementation.

Think of it as having a senior developer available 24/7 who can:

Generate code from descriptions
Refactor existing code
Fix bugs and improve performance
Write tests and documentation
Explore new technologies quickly

The key advantage? Everything happens in your terminal. No browser tabs, no context switching, no copy-pasting. Just describe your task and get results.

Getting Started: Installation and Setup

Prerequisites

Before installing Claude Code, ensure you have:

Node.js 18+ (check with node --version)
npm installed and up to date
An Anthropic API key (get one at console.anthropic.com)

Installation Steps

Installing Claude Code is straightforward:

npm install -g @anthropic-ai/claude-code

Configure Your API Key

After installation, set your API key as an environment variable:

export ANTHROPIC_API_KEY="your-api-key-here"

For persistent configuration across sessions, add this to your shell profile:

For macOS/Linux:

echo 'export ANTHROPIC_API_KEY="your-api-key-here"' >> ~/.bashrc
# or ~/.zshrc if you use zsh
source ~/.bashrc

For Windows (PowerShell):

[Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "your-api-key-here", "User")

Verify Installation

Test that everything is working:

claude-code --version

You should see the version number if installation was successful.

Core Features & Capabilities

1. Code Generation

One of Claude Code's strongest features is generating code from natural language descriptions.

Example: Create a utility function to validate email addresses.

claude-code "Write a TypeScript function that validates email addresses with proper regex and returns meaningful error messages"

Claude will generate a production-ready function with:

Proper error handling
Input validation
Clear variable names
Comments explaining the logic

2. Code Refactoring

Have legacy code that needs modernization? Claude Code can refactor it:

claude-code "Refactor this React component to use hooks instead of class syntax" < MyComponent.jsx

It understands:

Modern language features and best practices
Performance optimizations
Code readability improvements
Migration patterns

3. Bug Fixing

Stuck on a bug? Provide context and Claude Code helps identify the issue:

claude-code "I have a memory leak in this Node.js service. It grows from 50MB to 500MB over 24 hours. Here's the code:" < service.js

Claude analyzes patterns and suggests fixes with explanations of what's happening.

4. Test Generation

Writing tests doesn't have to be tedious:

claude-code "Generate comprehensive Jest tests for this function, including edge cases" < utils.js

You get tests covering:

Happy path scenarios
Edge cases and boundaries
Error conditions
Integration points

5. Documentation

Keep your docs in sync with code:

claude-code "Generate JSDoc comments for this API handler with parameter descriptions and examples" < handler.js

Practical Workflows

Workflow 1: Rapid Prototyping

Building a new feature? Use Claude Code to scaffold quickly:

claude-code "Create a REST API endpoint for user authentication with JWT tokens. Include validation, error handling, and follow Express.js best practices"

You get a working foundation in seconds. Then refine based on your specific needs.

Workflow 2: Cross-Language Translation

Need to translate code between languages?

claude-code "Convert this Python Django view to a Node.js Express controller, maintaining the same logic and error handling"

This accelerates migrations and learning new frameworks.

Workflow 3: Code Review Automation

Get AI-powered code suggestions:

claude-code "Review this code for security vulnerabilities, performance issues, and adherence to best practices" < app.js

It identifies issues you might miss and explains the implications.

Workflow 4: Learning & Exploration

Unfamiliar with a framework? Learn by example:

claude-code "Show me how to set up GraphQL subscriptions in Apollo Server with real-world example code"

You get working examples that teach through code.

Advanced Tips & Tricks

Using File Input/Output

Process larger files efficiently:

# Read from file and save output
claude-code "Add comprehensive error handling" < messy-code.js > improved-code.js

# Process multiple files
for file in *.js; do
  claude-code "Add JSDoc comments" < "$file" > "documented-$file"
done

Context Windows

Claude Code handles substantial context. For large projects:

# Provide directory structure for context
claude-code "Here's my project structure:
$(find . -type f -name '*.ts' | head -20)

Now add TypeScript strict mode compatibility to these files"

Iterative Refinement

Get feedback-driven results:

# First pass
claude-code "Generate a sorting algorithm" > algorithm.js

# Review and refine
claude-code "Optimize this sorting algorithm for space complexity and add detailed comments" < algorithm.js

Git Integration

Automate code improvements across your repository:

# Find all utility files and improve them
git ls-files "src/utils/**/*.js" | while read file; do
  claude-code "Modernize and optimize this utility" < "$file" > "$file.new"
  mv "$file.new" "$file"
done

Best Practices for Effective Usage

1. Be Specific and Contextual

❌ Vague: claude-code "write a function"

✅ Specific: claude-code "Write a React hook that manages form validation state, supporting custom validators and returning touched field tracking"

2. Provide Constraints

Guide Claude with requirements:

claude-code "Create an API client with:
- Retry logic with exponential backoff
- Request timeout of 5 seconds
- Automatic request/response logging
- TypeScript types"

3. Include Examples

Show what you want:

claude-code "Generate a function that transforms this data format:
Input: {name: 'John', birthYear: 1990}
Output: {displayName: 'John', age: 34}

Handle missing fields and validate input"

4. Specify Language and Style

Be explicit about preferences:

claude-code "Write a data fetching utility in TypeScript using async/await, with error boundaries and retry logic. Use functional programming patterns."

5. Review Before Committing

Always review Claude's output:

# Review the generated code
claude-code "your task" | less

# Test it before using
claude-code "your task" | node --check

Common Use Cases

API Development

Generate REST endpoints with validation
Create GraphQL resolvers
Design and implement authentication flows
Build database schemas with migrations

Frontend Development

Create React components with hooks
Generate state management boilerplate
Build responsive layouts
Implement form handling and validation

DevOps & Infrastructure

Write deployment scripts
Generate Docker configurations
Create CI/CD pipeline configurations
Develop infrastructure-as-code templates

Data Processing

Create data transformation pipelines
Generate data validation functions
Build ETL processes
Process and analyze logs

Testing

Generate unit tests
Create integration test scenarios
Build test fixtures and mocks
Generate performance benchmarks

Troubleshooting & Common Issues

Issue: "API Key Not Found"

Solution: Verify your API key is set:

echo $ANTHROPIC_API_KEY

If empty, set it again:

export ANTHROPIC_API_KEY="your-key"

Issue: Rate Limiting

Solution: Claude Code respects Anthropic's rate limits. If you hit limits:

Implement backoff delays between requests
Batch smaller tasks together
Contact Anthropic support for higher limits

Issue: Unexpected Output Quality

Solution: Improve your prompts:

Add more context and constraints
Specify language and framework versions
Include examples of expected output
Break complex tasks into smaller steps

Issue: Token/Context Limits

Solution: For very large files:

Split into smaller, logical chunks
Provide high-level summaries instead of full code
Focus on specific sections that need work

Performance Considerations

Claude Code is designed for developer productivity, not production deployment. Keep these in mind:

Response Time: First response typically arrives in 2-5 seconds
Token Usage: Each request consumes API tokens; monitor your usage
Context Window: Claude can handle substantial code files, but very large prompts may be slower
Accuracy: Always review and test generated code, especially for critical paths

Real-World Examples

Example 1: Rapid API Scaffolding

claude-code "Create a complete Express.js REST API for a todo application with:
- GET /todos (list all)
- POST /todos (create)
- PUT /todos/:id (update)
- DELETE /todos/:id (delete)
- Input validation
- Error handling
- Logging
Use in-memory storage for now"

Example 2: TypeScript Migration

claude-code "Convert this JavaScript file to TypeScript with proper types. Infer types where needed and add JSDoc where types can't be inferred" < app.js

Example 3: Performance Optimization

claude-code "Profile this function and optimize it for performance. Use algorithmic improvements if possible" < slow-function.js

Limitations & When Not to Use Claude Code

Claude Code is powerful, but it's not a silver bullet:

Critical Security: Don't use for cryptographic implementations without expert review
System Design: Not a replacement for architectural planning and design reviews
Debugging Production Issues: Use for investigation but combine with monitoring and logs
Performance-Critical Code: Should be benchmarked and profiled after generation
Novel Algorithms: May need refinement for cutting-edge approaches

Always apply human judgment and domain expertise.

Next Steps

Getting More Value

Integrate into your workflow: Create shell aliases for frequent tasks
Build scripts: Automate code improvements across your projects
Combine with other tools: Use alongside linters, formatters, and tests
Share learnings: Document what works well in your team

Learn More

Claude Code Documentation
Anthropic Console - Manage API keys and monitor usage
Claude API Documentation - Deep dive into capabilities

Explore Advanced Features

As you get comfortable, explore:

MCP server integration for extended capabilities
Custom prompt templates for your team's patterns
Automation scripts for repetitive improvements
Integration with your existing development tools

Conclusion

Claude Code represents a shift in how developers can work—less time on boilerplate and routine tasks, more time on design and problem-solving. It's a tool that scales with your needs, whether you're a solo developer shipping quickly or part of a larger team improving code quality.

Start small. Try Claude Code on a simple task in your next project. You'll quickly discover how it fits into your workflow and where it delivers the most value.

The future of development isn't about writing less code—it's about writing better code faster. Claude Code is one of your best companions on that journey.

Have You Used Claude Code?

Share your experience! What tasks have you automated? What surprised you about the results? Drop a comment below—I'd love to hear how it's changed your development process.

Credits: This guide covers Claude Code as of 2024. For the latest features and updates, check the official documentation.

Deploying Vite + React App to Firebase with Staging and Production Environments

Aqib Nawaz — Wed, 15 Oct 2025 11:05:58 +0000

Learn how to configure and deploy your Vite + React app with separate Firebase Hosting environments for staging and production.

Deploying a React + Vite application to Firebase Hosting is super fast. But how do you deploy both a staging and production version to two separate hosting URLs?

In this guide, you'll learn how to:

✅ Configure environment-specific .env files
✅ Create two Firebase Hosting sites (staging & production)
✅ Use vite build modes and deploy via simple npm scripts
✅ Avoid common 404 errors with Firebase Hosting

Let’s get started.

🧱 Project Setup

If you’re using Vite and Firebase, your package.json probably looks something like this:

{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "firebase": "^11.6.1",
    "react": "^19.0.0",
    "react-dom": "^19.0.0"
  }
}

You also have a firebaseConfig.js with the Firebase initialization.

🌍 Step 1: Add `.env` Files for Staging & Production

Create two environment files in your project root:

`.env.staging`

VITE_FIREBASE_API_KEY=your-staging-api-key
VITE_FIREBASE_AUTH_DOMAIN=staging-yourproject.firebaseapp.com
VITE_FIREBASE_PROJECT_ID=your-staging-id
VITE_FIREBASE_STORAGE_BUCKET=...
VITE_FIREBASE_MESSAGING_SENDER_ID=...
VITE_FIREBASE_APP_ID=...
VITE_FIREBASE_MEASUREMENT_ID=...

`.env.production`

VITE_FIREBASE_API_KEY=your-prod-api-key
VITE_FIREBASE_AUTH_DOMAIN=yourproject.firebaseapp.com
VITE_FIREBASE_PROJECT_ID=your-prod-id
VITE_FIREBASE_STORAGE_BUCKET=...
VITE_FIREBASE_MESSAGING_SENDER_ID=...
VITE_FIREBASE_APP_ID=...
VITE_FIREBASE_MEASUREMENT_ID=...

In your firebaseConfig.js, use:

const firebaseConfig = {
  apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
  storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
  messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
  appId: import.meta.env.VITE_FIREBASE_APP_ID,
  measurementId: import.meta.env.VITE_FIREBASE_MEASUREMENT_ID,
};

🔥 Step 2: Create Hosting Sites on Firebase

We’ll now set up two hosting URLs:

https://yourproject.web.app → Production
https://staging-yourproject.web.app → Staging

✨ Create staging site:

Go to Firebase Console
Open your project
Go to Hosting
Click the dropdown arrow next to the current site
Click Add another site
Use site ID: staging-yourproject

🏷️ Step 3: Apply Hosting Targets

In your terminal:

firebase target:apply hosting production yourproject
firebase target:apply hosting staging staging-yourproject

⚙️ Step 4: Update `firebase.json`

Update your firebase.json to support both targets:

{
  "hosting": [
    {
      "target": "production",
      "public": "dist",
      "ignore": ["firebase.json", "**/.*", "**/node_modules/**"],
      "rewrites": [{ "source": "**", "destination": "/index.html" }]
    },
    {
      "target": "staging",
      "public": "dist",
      "ignore": ["firebase.json", "**/.*", "**/node_modules/**"],
      "rewrites": [{ "source": "**", "destination": "/index.html" }]
    }
  ]
}

🔧 Step 5: Update `package.json` Scripts

Add build and deploy commands for each environment:

"scripts": {
  "dev": "vite",
  "dev:staging": "vite --mode staging",
  "dev:production": "vite --mode production",
  "build:staging": "vite build --mode staging",
  "build:production": "vite build --mode production",
  "deploy:staging": "npm run build:staging && firebase deploy --only hosting:staging",
  "deploy:production": "npm run build:production && firebase deploy --only hosting:production"
}

🚀 Step 6: Deploy It!

Deploy to staging:

npm run deploy:staging

Deploy to production:

npm run deploy:production

💠 Troubleshooting

🔴 404: `Requested entity was not found`

You likely tried to deploy to a Firebase Hosting site that doesn’t exist.

✅ Fix: Create it via Firebase Console → Hosting → Add Site.

🔴 `auth/invalid-api-key`

Your .env isn’t being loaded properly.

✅ Fix: Check the VITE_ prefix and make sure you’re building with the correct mode:

vite build --mode staging

🧠 Final Thoughts

Using Firebase Hosting Targets with Vite modes gives you a clean, scalable way to manage multiple environments — with separate hosting URLs and .env configurations.

This setup works great for teams, CI/CD workflows, and A/B testing deployments.

Happy shipping! 🚀

💬 Questions or feedback? Leave a comment or reach out on Twitter!

Step-by-Step Guide to Set Up and Test Your Slack App with google cloud functions

Aqib Nawaz — Sun, 25 May 2025 08:25:04 +0000

1. Login to slack app

create a workspace

2. Create a Slack App

Go to https://api.slack.com/apps
Click "Create An App"
Select "From scratch"
Enter an App Name (e.g., "check blocked users") and select your workspace
Click on "Create App"
You will get 'Basic information' interface
Under the 'Basic information', open "Add features and functionality"

3. Creating Bot

Select "Bots".
You will be redirected to "App Home".
Under the "First, assign a scope to your bot token", click the button "Review Scopes to Add".
You will be redirected to "OAuth & Permissions".
Under the "OAuth & Permissions", scroll to "Scopes", open "Bot Token Scopes".
Click on "Add an OAuth Scope".
Add app_mentions:read To view messages (that directly mention @checkblockedusers in conversations).
Add chat:write to (send messagae as @checkBlockedUser).
Add channels:history(View messages and other content in public channels that checkusers has been added to)
Scroll up to "OAuth Tokens for Your Workspace" and click on "Install to Workspace".

4. Get Your Bot Token

Click on "Allow", you will be redirected to "OAuth and Permissions" again,
Copy the "Bot User OAuth Token" and save it for later use in firebase functions.

5. Set Up Event Subscriptions

In the left sidebar, click on "Event Subscriptions" and "Enable Events".
In the Request URL, paste the webhook url, where you want to get events, i.e onRequest cloud function URL in our case. which well get afer step 6.
Open "Subscribe to bot events", add app_mention:read
Click "Save Changes" at the bottom of the page

6. Setup firebase cloud functions

create onRequest firebase cloud fucntion and deploy it, copy the function url to paste in "Event subscription"

7. Add Your App to a Channel

Open your Slack workspace
Go to the channel where you want to add the bot
Type /invite @YourBotName (replace with your bot's username)

8. Test bot

Mention bot with text such as "@YourBotName abc" or "@YourBotName test@gmai.com".
Your bot should respond with whether the user is blocked or not

Create AI-Powered Store Assistant Bot for Natural Language Inventory queries using BigQuery, Firestore, GFCs, and Vertex AI

Aqib Nawaz — Wed, 16 Apr 2025 14:48:34 +0000

Introduction

Modern retail stores need more than just basic inventory tracking. They need intelligent assistants that can answer questions about products, stock levels, and sales trends. In this tutorial, I'll walk you through building a conversational store assistant bot that leverages Google Cloud Tools such as Firestore, BigQuery, and Google's Vertex AI to create a natural language interface for your store's inventory data.

What you'll learn:

Setting up a BigQuery dataset for product history tracking
[Optional] Migrating store data from Firestore to BigQuery (Skip if your data is already in BigQuery or another database)
Creating REST API endpoints for product analytics
Building an AI-powered store assistant using Vertex AI's Gemini model

Prerequisites

Before we begin, make sure you have:

A Google Cloud Platform account
Firebase project set up with Firestore (Required for firestore and Google cloud functions)
Node.js and npm installed
Basic understanding of Express.js
Firebase CLI installed (npm install -g firebase-tools)

Setting Up The Environment

First, you'll need to set up the necessary permissions and service accounts:

Create a service account in the GCP console with the following roles:
- BigQuery Admin
- Firebase/Firestore Admin
- Vertex AI User
Download the service account key file and store it securely
Required npm packages for our project:
- firebase-admin
- @google-cloud/bigquery
- express
- cors
- firebase-functions
- axios
- @google-cloud/vertexai

Step 1: Creating a BigQuery Table for Product History Data

Let's start by creating our BigQuery table to store product transaction history by running the following code:

const serviceAccountPath = "./path-to-your-service-account.json";
const { BigQuery } = require('@google-cloud/bigquery');

// Initialize services
const bigquery = new BigQuery({
  keyFilename: serviceAccountPath,
  projectId: "your-project-id"
});

async function createTable() {
  const datasetId = 'store_assistant';
  const tableId = 'product_history';

  // Define schema based on your store's product data structure
  const schema = [
    { name: 'transaction_id', type: 'STRING', mode: 'REQUIRED' },
    { name: 'product_id', type: 'STRING' },
    { name: 'category_id', type: 'STRING' },
    { name: 'sku', type: 'STRING' },
    { name: 'quantity', type: 'NUMERIC' },
    { name: 'unit_count', type: 'NUMERIC' },
    { name: 'current_stock', type: 'NUMERIC' },
    { name: 'unit_price', type: 'NUMERIC' },
    { name: 'product_name', type: 'STRING' },
    { name: 'product_code', type: 'STRING' },
    { name: 'attributes', type: 'STRING' },
    { name: 'status', type: 'STRING' },
    { name: 'category', type: 'STRING' },
    { name: 'tags', type: 'STRING' },
    { name: 'notes', type: 'STRING' },

    // Timestamp
    { name: 'transaction_date', type: 'TIMESTAMP' }
  ];

  const options = {
    schema,
    location: 'US' (optional)
  };

  try {
    // Create the dataset if it doesn't exist
    await bigquery.createDataset(datasetId, {
      location: 'US'
    }).catch(err => {
      if (err.code !== 409) throw err; // 409 means dataset already exists
    });

    // Create the table
    const [table] = await bigquery.dataset(datasetId).createTable(tableId, options);
    console.log(`✅ Table ${table.id} created successfully.`);
  } catch (error) {
    console.error('Error creating table:', error);
  }
}

createTable().catch(console.error);

Step 2: [Optional] Migrating Data from Firestore to BigQuery

Now, let's migrate your existing store data from Firestore to BigQuery for advanced analytics:

const admin = require('firebase-admin');
const { BigQuery } = require('@google-cloud/bigquery');

// Initialize Firebase
admin.initializeApp({
  credential: admin.credential.cert('./path-to-your-service-account.json') //You can also initialize it as default
});

const db = admin.firestore();

// Initialize BigQuery
const bigquery = new BigQuery({
  keyFilename: './path-to-your-service-account.json'
});

const datasetId = 'store_assistant';
const tableId = 'product_history';

// Define fields structure as per you requirements
//========NOTE=====
//This is not required if you data has already the required structure
const nestedFields = [
  "quantity", "unit_count", "current_stock", "unit_price",
  "product_name", "product_code", "attributes", "status",
  "category", "tags", "notes", "transaction_date"
];
const directFields = ["product_id", "category_id", "sku"];

// Helper to parse numbers safely
function parseNumeric(value) {
  const num = parseFloat(value);
  return isNaN(num) ? null : num;
}

async function processDocs() {
  let lastDoc = null;
  const batchSize = 1000; // Adjust based on your document size
  let processedCount = 0;
  let buffer = [];

  console.log('🚀 Starting migration from Firestore to BigQuery...');

  while (true) {
    // Build query with pagination
    let query = db.collection('product_history').orderBy('product_id').limit(batchSize);
    if (lastDoc) query = query.startAfter(lastDoc);

    const snapshot = await query.get();
    if (snapshot.empty) break;

    // Process each document
    snapshot.docs.forEach(doc => {
      const data = doc.data();
      const result = { transaction_id: doc.id };

      // Process nested fields (fields with values array)
      nestedFields.forEach(field => {
        const fieldData = data[field];
        let value = (fieldData && Array.isArray(fieldData.values) && fieldData.values.length > 0)
          ? fieldData.values[0]
          : "";

        // Convert values based on field type
        switch (field) {
          case 'quantity':
          case 'unit_count':
          case 'current_stock':
          case 'unit_price':
            value = parseNumeric(value) || null;
            break;
          case 'transaction_date':
            if (typeof value === 'string') {
              const date = new Date(value);
              value = isNaN(date.getTime()) ? null : date;
            } else if (value && value._seconds) {
              // Handle Firestore timestamps
              value = new Date(value._seconds * 1000);
            } else {
              value = null;
            }
            break;
          default:
            value = typeof value === 'string' ? value : String(value ?? '');
        }

        result[field] = value;
      });

      // Process direct fields
      directFields.forEach(field => {
        result[field] = data[field] || "";
      });

      buffer.push(result);
      processedCount++;
    });

    // Insert batch to BigQuery
    if (buffer.length > 0) {
      await bigquery.dataset(datasetId).table(tableId).insert(buffer, {
        ignoreUnknownValues: true,
        skipInvalidRows: true
      });
      console.log(`✅ Inserted ${buffer.length} rows into BigQuery`);
      buffer = [];
    }

    lastDoc = snapshot.docs[snapshot.docs.length - 1];
    console.log(`📊 Processed ${processedCount} documents...`);
  }

  console.log(`\n🎉 Migration complete! Migrated ${processedCount} records to BigQuery.`);
}

processDocs().catch(err => {
  console.error('❌ Error during migration:', err);
});

Note: If your data is already formatted, then skip the formatting logic.
Migrate it straight to the BigQuery

Step 3: Creating API Endpoints for Store Assistant Bot

Now let's create API endpoints that will provide various product analytics for the store assistant bot. We'll use Google cloud functions to host our storeAPI and storeBot:

**Create directory and initialize firebase cloud functions in it. Please checkout documentation for how to initialize.

Create storeAPI.js inside functions directory and create express API app and export it.

Note: API end points depends on you requirements


const cors = require("cors");
const { BigQuery } = require("@google-cloud/bigquery");
const express = require("express");
const { onRequest } = require("firebase-functions/v2/https");
const { logger } = require("firebase-functions");
const app = express();

// Middleware
app.use(cors({ origin: true }));
app.use(express.json());

// Initialize BigQuery
const bigquery = new BigQuery();

const datasetId = "store_assistant";
const tableId = "product_history";

// Test endpoint
app.get("/test", async (req, res) => {
  logger.info("This is test end point");
  res.status(200).json({ status: "ok", message: "Store Assistant API is working" });
});


// 1. Get product history for a specific product
app.get(
  "/product-history",
  async (req, res) => {
    const productCode = req.query.productCode;
    logger.info("product-history: Received request for productCode:", productCode);

    if (!productCode) {
      logger.warn("product-history: Missing productCode parameter");
      return res.status(400).json({
        error: "Missing information",
        message: "Please provide a product code to check history"
      });
    }

    const query = `
    SELECT *
    FROM \`${datasetId}.${tableId}\`
    WHERE product_code = @productCode
    ORDER BY transaction_date DESC
    `;

    const options = {
      query,
      params: { productCode },
    };

    try {
      const [rows] = await bigquery.query(options);
      logger.info(`product-history: Query completed, found ${rows.length} records`);

      if (rows.length === 0) {
        return res.status(404).json({
          success: false,
          message: `No history found for product with code ${productCode}`,
          data: {
            productCode: productCode,
            historyCount: 0
          }
        });
      }

      res.status(200).json({
        success: true,
        message: `Product ${rows[0].product_name} has ${rows.length} recorded events`,
        data: {
          productCode: productCode,
          productName: rows[0].product_name,
          code: productCode,
          historyCount: rows.length,
          history: rows.map(row => ({
            date: row.transaction_date,
            quantity: row.quantity,
            price: row.unit_price,
            type: row.transaction_type || "Unknown"
          }))
        }
      });
    } catch (error) {
      logger.error("product-history: BigQuery error:", error);
      res.status(500).json({
        success: false,
        message: "Error retrieving product history data",
        error: error.message
      });
    }
  }
);

// 2. Get most popular product with customers
app.get(
  "/most-popular-product",
  async (req, res) => {
    logger.info("most-popular-product: Executing query");

    const query = `
    SELECT product_id, sku, product_name, product_code, COUNT(*) as transaction_count
    FROM \`${datasetId}.${tableId}\`
    GROUP BY product_id, sku, product_name, product_code
    ORDER BY transaction_count DESC
    LIMIT 1
    `;

    try {
      const [rows] = await bigquery.query(query);

      if (rows.length === 0) {
        return res.json({
          success: false,
          message: "No product history records found in the system"
        });
      }

      res.status(200).json({
        success: true,
        message: `${rows[0].product_name} is the most popular product with ${rows[0].transaction_count} customer interactions`,
        data: {
          productId: rows[0].product_id,
          sku: rows[0].sku,
          productName: rows[0].product_name,
          productCode: rows[0].product_code,
          transactionCount: rows[0].transaction_count
        }
      });
    } catch (error) {
      logger.error("most-popular-product: BigQuery error:", error);
      res.status(500).json({
        success: false,
        message: "Error retrieving product popularity data",
        error: error.message
      });
    }
  }
);

// 3. Get this month's best seller
app.get(
  "/monthly-best-seller",
  async (req, res) => {
    logger.info("monthly-best-seller: Executing query for current month");

    const query = `
    SELECT product_id, sku, product_name, COUNT(*) as transaction_count
    FROM \`${datasetId}.${tableId}\`
    WHERE EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
    AND EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
    GROUP BY product_id, sku, product_name
    ORDER BY transaction_count DESC
    LIMIT 1
    `;

    try {
      const [rows] = await bigquery.query(query);

      if (rows.length === 0) {
        return res.json({
          success: false,
          message: "No sales recorded for the current month"
        });
      }

      // Get current month name
      const monthNames = [
        "January", "February", "March", "April", "May", "June",
        "July", "August", "September", "October", "November", "December"
      ];
      const currentMonth = monthNames[new Date().getMonth()];

      res.status(200).json({
        success: true,
        message: `${rows[0].product_name} is our best seller this month (${currentMonth}) with ${rows[0].transaction_count} sales`,
        data: {
          month: currentMonth,
          productId: rows[0].product_id,
          sku: rows[0].sku,
          productName: rows[0].product_name,
          transactionCount: rows[0].transaction_count
        }
      });
    } catch (error) {
      logger.error("monthly-best-seller: BigQuery error:", error);
      res.status(500).json({
        success: false,
        message: "Error retrieving monthly sales data",
        error: error.message
      });
    }
  }
);

// 4. Get store inventory value and top products
app.get(
  "/store-inventory",
  async (req, res) => {
    logger.info("store-inventory: Executing inventory value query");

    const query = `
    WITH current_inventory AS (
      SELECT product_id, product_name, sku, product_code,
        SAFE_CAST(current_stock AS FLOAT64) as stock_qty,
        SAFE_CAST(unit_price AS FLOAT64) as item_price,
        (SAFE_CAST(current_stock AS FLOAT64) * SAFE_CAST(unit_price AS FLOAT64)) as total_value
      FROM \`${datasetId}.${tableId}\`
      WHERE SAFE_CAST(current_stock AS FLOAT64) > 0
        AND SAFE_CAST(unit_price AS FLOAT64) > 0
    )

    SELECT 
      (SELECT SUM(total_value) FROM current_inventory) as total_inventory_value,
      ARRAY(
        SELECT AS STRUCT product_id, product_name, sku, product_code, stock_qty, item_price, total_value
        FROM current_inventory
        ORDER BY total_value DESC
        LIMIT 5
      ) as top_valuable_items
    `;

    try {
      const [rows] = await bigquery.query(query);

      if (rows.length === 0) {
        return res.json({
          success: false,
          message: "No inventory data found in the system"
        });
      }

      const formatter = new Intl.NumberFormat('en-US', {
        style: 'currency',
        currency: 'USD'
      });

      const totalValue = formatter.format(rows[0].total_inventory_value);

      const topItems = rows[0].top_valuable_items.map(item => ({
        productId: item.product_id,
        sku: item.sku,
        name: item.product_name,
        code: item.product_code,
        quantity: item.stock_qty,
        unitPrice: formatter.format(item.item_price),
        totalValue: formatter.format(item.total_value)
      }));

      res.status(200).json({
        success: true,
        message: `Our store's current inventory is valued at ${totalValue}`,
        data: {
          totalInventoryValue: totalValue,
          topItems: topItems
        }
      });
    } catch (error) {
      logger.error("store-inventory: BigQuery error:", error);
      res.status(500).json({
        success: false,
        message: "Error retrieving store inventory data",
        error: error.message
      });
    }
  }
);

// Additional endpoints to implement:
// - '/trending-products' - Products with increasing customer interest
// - '/product-recommendations' - AI-based product recommendations
// - '/low-stock-alerts' - Identify products that need replenishment

// Error handling middleware
app.use((err, req, res, next) => {
  logger.error("Global error handler:", err);
  res
    .status(500)
    .json({
      success: false,
      message: "Something went wrong with your request",
      error: err.message
    });
});

// Export the API as
module.exports = { storeAPI: app }

Step 4: Integrating AI with Vertex AI for the Store Assistant Bot

Now for the exciting part! Let's add the AI layer using Google's Vertex AI to create a conversational store assistant bot that can answer customer questions.

Create another file storeBot.js in the functions folder with express app and export it at the end.

const express = require('express');
const axios = require('axios');
const { VertexAI } = require('@google-cloud/vertexai');
const app = express();
app.use(express.json());

// Configuration
const API_BASE_URL = 'https://your-region-your-project.cloudfunctions.net/api';
const PROJECT_ID = "your-project-id";
const LOCATION = 'us-central1';
const MODEL_ID = 'gemini-1.5-pro'; // Or the latest available model

// Create VertexAI instance
const vertexAI = new VertexAI({project: PROJECT_ID, location: LOCATION});
const generativeModel = vertexAI.getGenerativeModel({
  model: MODEL_ID,
  generationConfig: {
    temperature: 0.2, 
    maxOutputTokens: 1024,
  }
});

// Define the API endpoints map
const API_ENDPOINTS = {
  productHistory: `${API_BASE_URL}/product-history`,
  mostPopularProduct: `${API_BASE_URL}/most-popular-product`,
  monthlyBestSeller: `${API_BASE_URL}/monthly-best-seller`,
  storeInventory: `${API_BASE_URL}/store-inventory`,
  trendingProducts: `${API_BASE_URL}/trending-products`,
  productRecommendations: `${API_BASE_URL}/product-recommendations`,
  lowStockAlerts: `${API_BASE_URL}/low-stock-alerts`
};

// Helper function to make API calls
async function callAPI(endpoint, params = {}) {
  try {
    let url = API_ENDPOINTS[endpoint];
    if (!url) {
      throw new Error(`Unknown endpoint: ${endpoint}`);
    }

    // Add query parameters if provided
    if (Object.keys(params).length > 0) {
      const queryParams = new URLSearchParams();
      for (const [key, value] of Object.entries(params)) {
        queryParams.append(key, value);
      }
      url = `${url}?${queryParams.toString()}`;
    }

    const response = await axios.get(url);
    return response.data;
  } catch (error) {
    console.error(`Error calling ${endpoint}:`, error.message);
    if (error.response) {
      return error.response.data;
    }
    return { success: false, message: error.message };
  }
}

// Function to analyze customer query and determine API endpoint
async function analyzeQuery(query) {
  try {
    const prompt = `
    You are a helpful store assistant bot. Your task is to analyze the customer's query and determine which API endpoint should be called, along with any required parameters.

    Available endpoints:
    1. productHistory - Requires productCode parameter (for queries about history or information for a specific product)
    2. mostPopularProduct - No parameters needed (for queries about which product is most popular overall)
    3. monthlyBestSeller - No parameters needed (for queries about best sellers this month)
    4. storeInventory - No parameters needed (for queries about store inventory value or available products)
    5. trendingProducts - Optional 'days' parameter (default 30) for queries about currently trending products
    6. productRecommendations - Requires productId parameter (for queries about recommended related products)
    7. lowStockAlerts - No parameters needed (for queries about products that need to be restocked)

    Customer query: "${query}"

    Respond with a valid JSON object containing:
    1. "endpoint": The API endpoint that should be called
    2. "params": An object containing any parameters needed for the API call
    3. "explanation": Brief explanation of why this endpoint was selected
    `;

    try {
      const result = await generativeModel.generateContent({
        contents: [{ role: "user", parts: [{ text: prompt }] }]
      });

      const responseText = result.response.candidates[0].content.parts[0].text;

/*===================
 You can see excessive use of '\', it is not part of code but to avoid markdown syntax errors in dev.to blog
==================*/

       // Extract the JSON object from the response
      let jsonMatch = responseText.match(/\`\`\`json\n([\s\S]*?)\n\`\`\`/) || 
                responseText.match(/\`\`\`\n([\s\S]*?)\n\`\`\`/) ||
                responseText.match(/{[\s\S]*?}/);

      let jsonStr = jsonMatch ? jsonMatch[0] : responseText;

      // Clean up the string to ensure it's valid JSON
      jsonStr = jsonStr.replace(/`\`\`json\n|`\`\`\n|`\`\`/g, '').trim();




      return JSON.parse(jsonStr);
    } catch (error) {
      console.error('Vertex AI error:', error);
      // Fall back to basic intent matching
      return fallbackQueryAnalysis(query);
    }
  } catch (error) {
    console.error('Error analyzing query:', error);
    return {
      endpoint: null,
      params: {},
      explanation: `Error analyzing query:+ ${error.message}`
    };
  }
}

// Function to format API response into natural language for the store assistant bot
async function formatResponse(apiResponse, userQuery, endpoint) {
  try {
    const prompt = `
    You are a helpful store assistant bot. Your task is to format the API response into a natural, conversational response that addresses the customer's query.

    Customer query: "${userQuery}"

    API endpoint used: ${endpoint}

    API response: ${JSON.stringify(apiResponse)}

    Format your response in a natural, conversational way that:
    1. Directly answers the customer's question
    2. Highlights the most important information from the API response
    3. Provides context where helpful
    4. Is concise but complete
    5. Sounds like a helpful store assistant, not like a computer

    Your response should be friendly and helpful, like a knowledgeable store employee.
    `;

    const result = await generativeModel.generateContent({
      contents: [{ role: "user", parts: [{ text: prompt }] }]
    });

    return result.response.candidates[0].content.parts[0].text;
  } catch (error) {
    console.error('Error formatting response:', error);
    return `I found some information about that, but I'm having trouble putting it into words. Here's what I know: ${JSON.stringify(apiResponse.data || apiResponse)}`;
  }
}

// Main endpoint to process customer queries
app.post('/query', async (req, res) => {
  try {
    const { query } = req.body;

    if (!query) {
      return res.status(400).json({ 
        success: false, 
        message: 'Please provide a question about our products or inventory' 
      });
    }

    // Step 1: Analyze the query to determine the API endpoint
    const analysis = await analyzeQuery(query);

    // Step 2: If we can't determine the endpoint, ask for more information
    if (!analysis.endpoint) {
      return res.json({
        success: true,
        response: "I'm not sure what product information you're looking for. Could you be more specific? For example, you can ask about a specific product, our best sellers, or what's in stock."
      });
    }

    // Step 3: Call the appropriate API endpoint
    const apiResponse = await callAPI(analysis.endpoint, analysis.params);

    // Step 4: Format the response into natural language
    const formattedResponse = await formatResponse(apiResponse, query, analysis.endpoint);

    // Step 5: Return the formatted response
    res.json({
      success: true,
      response: formattedResponse,
      raw: {
        analysis: analysis,
        apiResponse: apiResponse
      }
    });

  } catch (error) {
    console.error('Error processing query:', error);
    res.status(500).json({ 
      success: false, 
      message: "I'm having trouble understanding your question right now. Could you try asking it differently?",
      error: error.message
    });
  }
});

// Export the Bot APP as
module.exports = { storeBot: app }

Step 5: Deploying Google cloud functions

Now inside index.js file in your functions directory:
import all the storeAPI and storeBot.


const admin = require("firebase-admin");
const { onRequest } = require("firebase-functions/v2/https");
// Initialize Firebase App
admin.initializeApp();

const storeAPI = require('./storeAPI.js');
const storeBot = require('./storeBot.js');

//Using onRequest for both apps
exports.api = onRequest(storeAPI);
exports.bot = onRequest(storeBot);

Now deploy to Firebase with cli:

firebase deploy --only functions:api,functions:bot

Step 6: Testing and Using the Store Assistant Bot

Once deployed, you can integrate the bot into your store through:

Direct API calls to endpoints for specific product information
The conversational bot interface for natural language customer interactions

Example usage of the Store Assistant Bot:

// Via curl
curl -X POST https://your-region-your-project.cloudfunctions.net/bot/query \
  -H "Content-Type: application/json" \
  -d '{"query":"Do you have the wireless headphones in stock?"}'

// Example response
{
  "success": true,
  "response": "Yes, we currently have Premium Wireless Headphones in stock! We have 50 units available at $349.99 each. Would you like me to tell you more about their features?"
}

Advanced Features to Consider

Now that you have the basic store assistant bot working, here are some enhancements to consider:

Real-time updates: Set up a Firestore trigger to automatically update BigQuery when inventory changes
Customer preferences: Track and remember customer preferences to personalize recommendations
Enhanced bot capabilities: Implement follow-up questions and conversation memory
Sales predictions: Use historical data to predict popular products and adjust inventory
Voice interface: Connect to voice assistants for hands-free product queries in the store

Conclusion

We've built a powerful store assistant bot that combines the operational simplicity of Firebase with the analytical capabilities of BigQuery and the conversational intelligence of Vertex AI. This system allows store employees and customers to get instant answers about products using natural language questions instead of having to search through catalogs or ask multiple staff members.

The combination of these technologies provides several benefits:

Cost-effective: BigQuery's pay-per-query model keeps costs low
Scalable: Handles thousands of products and customer queries without performance issues
User-friendly: Natural language interface makes product information accessible to everyone
Customer satisfaction: Provides immediate answers to product questions, improving the shopping experience

I hope this tutorial helps you build your own intelligent store assistant bot! Feel free to reach out with questions in the comments.

Containerize Express APP and automate deployment to Google Cloud Run using GitHub Actions

Aqib Nawaz — Wed, 09 Apr 2025 06:50:18 +0000

This article provides step by step guide for setting up a complete CI/CD pipeline to deploy a Express API to Google Cloud Run using GitHub Actions.

What We'll do?

Builds a Docker container from your Express.js application
Pushes the container to Google Artifact Registry
Deploys the container to Google Cloud Run

All of this happens automatically whenever you push to your main branch.

Requirement before you start

A Google Cloud Platform account
A GitHub account
Basic familiarity with Node.js and Express
Git installed on your local machine

Step 1: Create a Simple Express Application

Let's start by creating a basic Express API. Create a new directory for your project and initialize it:

mkdir cloud-run-api
cd cloud-run-api
npm init -y
npm install express body-parser cors dotenv

Now, create an index.js file with the following content:

const express = require("express");
const bodyParser = require("body-parser");
require("dotenv").config();
const app = express();
const cors = require("cors");

app.use(cors());
app.use(express.json());
app.use(bodyParser.json());

app.get("/", (req, res) => {
    res.status(200).send("OK");
});

// Health check route sometime required by Cloud Run
app.get("/health", (req, res) => {
   res.status(200).send("Healthy");
});

app.get("/greeting", (req, res) => {
   res.status(200).send({
        message: "Hello, World!"
   });
});

const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => console.log(`Server started at port: ${port}`));

Important: Note the /health endpoint is sometime required by Cloud Run to properly verify your application is running.
if you miss to add, you may get following error

(gcloud.run.deploy) Revision 'github-cloud-run-service-00003-lbd' is not ready and cannot serve traffic. The user-provided container failed to start and listen on the port defined provided by the PORT=8080 environment variable within the allocated timeout. This can happen when the container port is misconfigured or if the timeout is too short

Update your package.json to include a start script:

{
  "scripts": {
    "start": "node index.js"
  }
}

Step 2: Containerize Your Application with Docker

Create a Dockerfile in your project root:

FROM node:22

# Create app directory
WORKDIR /app

# Install app dependencies
COPY package*.json ./
RUN npm install

# Bundle app source
COPY . .

# Ensure the PORT environment variable is properly used
EXPOSE 8080

# Start the server
CMD ["npm", "start"]

This Dockerfile:

Uses the official Node.js image
Installs dependencies before copying the application code (leveraging Docker layer caching)
Exposes port 8080 (though Cloud Run injects the actual port via environment variable)
Uses npm start to launch your application

Step 3: Enable Required Google Cloud APIs

Before continuing, you need to enable several Google Cloud APIs:

Go to the Google Cloud Console
Select or create a project
Navigate to "APIs & Services > Library"
Search for and enable:
- Artifact Registry API
- Cloud Run API
- Cloud Build API
- iAm API

Step 4: Create a Service Account for with necessary permissions for deployment

You'll need a service account :

Go to IAM & Admin > Service Accounts in Google Cloud Console
Click Create Service Account
Enter a name and description for your service account
Click "Create and Continue"
Add the following roles:
- Artifact Registry Admin: For managing container images
- Cloud Run Admin: For deploying and managing Cloud Run services
- Service Account User: For acting as the service account
Click "Done"
Once created, select the service account and go to the Keys tab
Click Add Key > Create new key
Choose JSON and click Create

A JSON key file will be downloaded to your computer. Keep this file secure!

Step 5: Add GitHub Repository Secrets

Now, let's add the necessary secrets to your GitHub repository:

Open your GitHub repository in a browser
Go to Settings > Secrets and variables > Actions
Add the following repository secrets:

Secret Name	Value
`GCP_DEPLOY_SA_KEY`	The entire content of the JSON key file downloaded earlier
`GCP_PROJECT_ID`	Your Google Cloud Project ID
`GCP_PROJECT_SA_NAME`	Email address of your service account
`REPOSITORY_NAME`	Name of your Artifact Registry repository (created in next step)
`GCP_LOCATION`	Your preferred Google Cloud region (e.g., `us-central1`)

Note: After adding these secrets, delete the JSON key file from your local machine.

Step 6: Create an Artifact Registry Repository to store Docker images

Visit the Artifact Registry in Google Cloud Console
Click Create Repository
Enter a name (this will be your REPOSITORY_NAME secret)
Choose a region (this should match your GCP_LOCATION secret)
Select Docker as the format
Leave other fields as default
Click Create

Step 7: Set Up the GitHub Actions Workflow

Create a .github/workflows directory in your project and add a deploy.yaml file:

name: Build and Deploy to Cloud Run

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Authenticate with Google Cloud
      uses: google-github-actions/auth@v1
      with:
        credentials_json: ${{ secrets.GCP_DEPLOY_SA_KEY }}

    - name: Set up Google Cloud SDK
      uses: google-github-actions/setup-gcloud@v1
      with:
        project_id: ${{ secrets.GCP_PROJECT_ID }}

    - name: Configure Docker to use gcloud as a credential helper
      run: |
        gcloud auth configure-docker ${{ secrets.GCP_LOCATION }}-docker.pkg.dev

    - name: Build and Push Docker image
      run: |
        IMAGE_URI="${{ secrets.GCP_LOCATION }}-docker.pkg.dev/${{ secrets.GCP_PROJECT_ID }}/${{ secrets.REPOSITORY_NAME }}/my-github-action:latest"
        echo "Building Docker image: $IMAGE_URI"
        docker build -t "$IMAGE_URI" .
        docker push "$IMAGE_URI"

    - name: Deploy to Cloud Run
      run: |
        gcloud run deploy github-cloud-run-service \
          --image "${{ secrets.GCP_LOCATION }}-docker.pkg.dev/${{ secrets.GCP_PROJECT_ID }}/${{ secrets.REPOSITORY_NAME }}/my-github-action:latest" \
          --platform managed \
          --region ${{ secrets.GCP_LOCATION }} \
          --port 8080 \
          --project ${{ secrets.GCP_PROJECT_ID }} \
          --service-account ${{ secrets.GCP_PROJECT_SA_NAME }} \
          --allow-unauthenticated

Note the --allow-unauthenticated flag, which makes your service publicly accessible.

Step 8: Commit and Push Your Code

Initialize a Git repository, commit your changes, and push to GitHub:

git init
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin https://github.com/your-username/your-repo-name.git
git push -u origin main

GitHub action will automatically deploy you API to cloud run

Testing Our API using the Cloud Run URL

Go to the Cloud Run section in Google Cloud Console
Click on your service name (github-cloud-run-service)
At the top of the overview page, you'll find the URL to your deployed service (usually something like https://github-cloud-run-service-abc123-uc.a.run.app)
Test API end point directly in any browser (Accessible because we add --allow-unauthenticated flag in Yaml file)

DEV Community: Aqib Nawaz

Master Claude Code: Setup, Features, Workflows, and Best Practices

The Complete Guide to AI-Powered Development in Your Terminal

What is Claude Code?

Getting Started: Installation and Setup

Prerequisites

Installation Steps

Configure Your API Key

Verify Installation

Core Features & Capabilities

1. Code Generation

2. Code Refactoring

3. Bug Fixing

4. Test Generation

5. Documentation

Practical Workflows

Workflow 1: Rapid Prototyping

Workflow 2: Cross-Language Translation

Workflow 3: Code Review Automation

Workflow 4: Learning & Exploration

Advanced Tips & Tricks

Using File Input/Output

Context Windows

Iterative Refinement

Git Integration

Best Practices for Effective Usage

1. Be Specific and Contextual

2. Provide Constraints

3. Include Examples

4. Specify Language and Style

5. Review Before Committing

Common Use Cases

API Development

Frontend Development

DevOps & Infrastructure

Data Processing

Testing

Troubleshooting & Common Issues

Issue: "API Key Not Found"

Issue: Rate Limiting

Issue: Unexpected Output Quality

Issue: Token/Context Limits

Performance Considerations

Real-World Examples

Example 1: Rapid API Scaffolding

Example 2: TypeScript Migration

Example 3: Performance Optimization

Limitations & When Not to Use Claude Code

Next Steps

Getting More Value

Learn More

Explore Advanced Features

Conclusion

Have You Used Claude Code?

Deploying Vite + React App to Firebase with Staging and Production Environments

🧱 Project Setup

🌍 Step 1: Add .env Files for Staging & Production

.env.staging

.env.production

🔥 Step 2: Create Hosting Sites on Firebase

✨ Create staging site:

🏷️ Step 3: Apply Hosting Targets

⚙️ Step 4: Update firebase.json

🔧 Step 5: Update package.json Scripts

🚀 Step 6: Deploy It!

Deploy to staging:

Deploy to production:

💠 Troubleshooting

🔴 404: Requested entity was not found

🔴 auth/invalid-api-key

🧠 Final Thoughts

Step-by-Step Guide to Set Up and Test Your Slack App with google cloud functions

1. Login to slack app

2. Create a Slack App

3. Creating Bot

4. Get Your Bot Token

5. Set Up Event Subscriptions

6. Setup firebase cloud functions

7. Add Your App to a Channel

8. Test bot

🌍 Step 1: Add `.env` Files for Staging & Production

`.env.staging`

`.env.production`

⚙️ Step 4: Update `firebase.json`

🔧 Step 5: Update `package.json` Scripts

🔴 404: `Requested entity was not found`

🔴 `auth/invalid-api-key`