DEV Community: Arya Mihir Singh

How I Migrated from PHP to ExpressJS Using AI

Arya Mihir Singh — Fri, 11 Apr 2025 23:32:41 +0000

Accelerating PHP to Express.js Migrations with AI: A Repeatable Pattern

Migrating legacy systems, such as moving from a PHP backend to Node.js/Express.js, presents significant challenges. These projects often involve understanding complex existing logic, rewriting features, and maintaining service continuity. This post outlines a repeatable, AI-assisted pattern to streamline this process, based on experiences from a recent migration project.

We will demonstrate this pattern using a common and critical feature: User Authentication (Login, Registration, Profiles).

Core Migration Strategy:

The approach focuses on abstracting requirements away from the legacy implementation, designing a modern API, leveraging AI for initial code generation, and then rigorously testing and integrating.

Legacy PHP -> Define Requirements -> Design API -> Generate Backend (AI-Assisted) -> Test API -> Generate Frontend (AI-Assisted) -> Integrate -> Complete

Prerequisites:

Before starting the migration for a specific feature, ensure you have:

Clear Functional Requirements: Document what the feature must accomplish, independent of the old PHP implementation.
Defined Database Schema: Have the target database schema (e.g., PostgreSQL, MySQL) designed and ready.
UI Designs: Have UI mockups (e.g., Figma) for the corresponding frontend components.

Feature Migration Example: User Authentication

Let's apply the pattern to user registration, login, and profile management.

Step 1: Define Functional Requirements

Goal: Document the essential business logic and user interactions for the feature.

Action:

List core user actions (e.g., Register, Login, View Profile, Update Profile).
For each action, specify: Required inputs, validation rules, processing steps, expected success outputs, and potential error conditions.

Example (Login):
- Input: Email, Password.
- Processing: Validate input formats. Verify user existence in the database. Compare provided password hash with stored hash. Generate a JWT upon successful verification.
- Success Output: 200 OK status with a JWT Token.
- Error Outputs: 400 Bad Request (invalid input format), 401 Unauthorized (invalid credentials).

AI Assistance (Conceptual - for understanding legacy code):
If needed, use an AI chat assistant to help decipher complex legacy code:

Act as a senior software engineer. Analyze the provided PHP code [or description] for user login. Extract the core functional requirements: inputs, validation steps, success output (data returned), and failure scenarios/error conditions. Focus on the business logic, not the specific PHP implementation.

Step 2: Design the API Contract

Goal: Define how the new Express.js service will communicate with clients (e.g., the frontend).

Action: Specify RESTful endpoints including HTTP methods, URL paths, request body structures (JSON), and expected response formats (JSON, status codes).

Example API Endpoints:
- POST /api/auth/register (Body: { email, password }) -> 201 Created { userId } or error.
- POST /api/auth/login (Body: { email, password }) -> 200 OK { token } or error.
- GET /api/users/me (Requires Authorization: Bearer <token>) -> 200 OK { userId, email, name, ... } or error.
- PUT /api/users/me (Requires Authorization: Bearer <token>, Body: { name, ... }) -> 200 OK { updatedProfile } or error.

(Conceptual Flow): [Client Application] <- (HTTP Request/Response) -> [Express.js API Service]

Step 3: Generate Backend Logic with AI Assistance

Goal: Use AI code generation tools to create the initial Express.js routes, controllers, and service logic based on the API design.

Action: Provide a detailed prompt to your chosen AI code generation tool (e.g., Codeium, Windsurf).

AI Prompt Example (Login Endpoint):

Act as a full-stack Node.js developer. Generate an Express.js API endpoint implementation for user login based on the following specifications:

**1. API Contract:**
   - Method: POST
   - Path: /api/auth/login
   - Request Body: JSON object with 'email' (string, valid email format) and 'password' (string, min 8 chars).
   - Success Response (200 OK): JSON object with 'token' (string, JWT).
   - Error Response (400 Bad Request): JSON { message: "Invalid input format" }
   - Error Response (401 Unauthorized): JSON { message: "Invalid email or password" }

**2. Technology Stack:**
   - Framework: Express.js 4.x
   - Language: JavaScript (ES6+) [or specify TypeScript]
   - Database: PostgreSQL
   - ORM: Prisma (Ensure Prisma Client is imported and used)
   - Authentication: JWT (using 'jsonwebtoken' library)
   - Password Hashing: bcrypt (using 'bcryptjs' library)

**3. Logic:**
   - Validate incoming request body for presence and format of email/password. Return 400 if invalid.
   - Query the PostgreSQL database via Prisma to find the user by 'email'.
   - If user not found, return 401.
   - If user found, compare the provided 'password' with the stored hashed password using bcrypt.compare().
   - If passwords don't match, return 401.
   - If passwords match, generate a JWT containing the user ID (e.g., { userId: user.id }). Use process.env.JWT_SECRET for the secret key and set an appropriate expiration (e.g., '1h').
   - Return 200 OK with the JWT: { token: generatedToken }.
   - Include basic try/catch blocks for database or JWT operations.

**4. Code Structure:**
   - Use Express Router.
   - Define a controller function (e.g., `loginUser`).
   - Include necessary imports (express, bcryptjs, jsonwebtoken, PrismaClient).

**5. Output:** Provide the complete code snippet for the route definition and associated controller function(s), with comments explaining key logic.

Important: AI-generated code is a starting point. Thoroughly review, debug, and refine the code. Implement comprehensive error handling, add security measures (e.g., input sanitization, rate limiting), and ensure it fully meets requirements and integrates correctly with your database schema.

Step 4: Test the API Thoroughly

Goal: Verify the backend service functions correctly in isolation before integrating it with the frontend.

Action: Use an API testing tool like Postman to test every endpoint defined in Step 2.

Test Scenarios:
- Valid Inputs: Verify expected success responses and data.
- Input Validation: Test invalid formats, missing fields, etc., ensure correct error responses (e.g., 400).
- Authentication/Authorization Logic: Test incorrect credentials, missing/invalid tokens for protected routes (expect 401/403), correct data return with valid tokens.
- Edge Cases: Test any known boundary conditions.
Iteration: If tests fail, debug the Express.js code (Step 3) and re-test until all endpoints behave as expected.

Step 5: Generate Frontend Components with AI Assistance

Goal: Create the basic UI structure based on your Figma designs using AI UI generation tools.

Action: Provide designs and requirements to a UI generation tool (e.g., v0.dev).

AI Prompt Example (Login Form - v0.dev Style):

Create a user login form component using React and Tailwind CSS, based on the provided Figma design [tool typically takes image/link input].

**Required Elements:**
- Form title: "Login"
- Labeled input field for Email (type="email").
- Labeled input field for Password (type="password").
- Submit button labeled "Log In".
- An area below the form to display potential error messages (initially hidden).

**Styling:**
- Apply Tailwind CSS utility classes.
- Match the layout, spacing, and typography from the Figma design.
- Ensure responsiveness.

**Basic Interaction Structure:**
- The component should manage state for email and password inputs.
- The submit button should trigger a submission handler function (to be implemented).
- The error display area should be capable of rendering text.

Refinement: Review the generated UI code. Use the tool's features or manually edit the code to match the design precisely and ensure accessibility.

Step 6: Integrate Frontend and Backend

Goal: Connect the generated frontend UI components to the tested Express.js API endpoints.

Action: Implement the client-side logic within your frontend framework (React, Vue, etc.).

API Calls: Use fetch or axios to interact with your API:
- Send POST /api/auth/login request on form submission.
- Send GET /api/users/me request (with Authorization header) when needed.
State Management: Handle UI updates based on API responses (loading states, error messages). Store authentication tokens securely (e.g., in state management or secure storage). Manage conditional rendering based on authentication status.
End-to-End Testing: Test the complete user flow through the UI to ensure seamless interaction between frontend and backend.

(Conceptual Flow): [Frontend Component (React)] <- (State Updates / API Calls) -> [Express.js API Service]

Applying the Pattern to Your Code

To migrate a specific feature from your PHP application:

Analyze Your PHP Feature: Understand its purpose, data dependencies, database interactions, and core business logic.
Abstract Requirements: Document the feature's essential inputs, outputs, and rules (Step 1), independent of the PHP implementation details. This is critical.
Follow the Pattern: Apply Steps 2 through 6 to design, build, test, and integrate the new Express.js service and corresponding frontend components for that specific feature.
Avoid Direct Translation: Do not attempt a line-by-line translation from PHP to Node.js. Instead, re-architect the feature using modern Node.js practices based on the abstracted requirements.

Conclusion:

While legacy migrations are complex, a structured approach combined with AI assistance can significantly accelerate the process. By focusing on clear requirements and API design before implementation, and using AI tools for initial code generation (followed by essential human review and refinement), development teams can migrate features from PHP to Express.js more efficiently and effectively. This pattern breaks the migration down into manageable, repeatable steps.

Building Multilingual Image Search with Marqo

Arya Mihir Singh — Sun, 28 Jan 2024 09:33:22 +0000

Introduction

Multilingual Image Search

For global businesses, multilingual image search can prove to be a critical component for enhancing accessibility of their search platforms and expand their content reach. As e-commerce and digital platforms grow internationally, multilingual capabilities become essential in tapping into new markets and demographics.

Why Marqo?

Marqo differentiates itself by integrating state-of-the-art multilingual CLIP models with dense retrieval techniques, facilitating accurate and context-aware image searches across 100 languages.

In this article, we will explore steps to set up and build multilingual image search. We'll be covering end-to-end flow from System Requirements to implementation to Use cases.

Prerequisites

Before implementing a multilingual image search with Marqo, ensure your system meets the following requirements:

System Requirements

Python Environment: Requires Python 3.7 or later.
Hardware Requirements:
- CPU: Modern multi-core processor (e.g., Intel Core i5/i7/i9, AMD Ryzen 5/7/9) with high clock speed for efficient processing.
- GPU: Recommended for performance acceleration, especially beneficial for larger datasets. CUDA-compatible GPUs are ideal.
Memory: Minimum of 8GB RAM; more is beneficial for large datasets.

Setup and installation

Lets start by downloading and installing Marqo:

Install Docker. Follow Docker Docs.
Use Docker to run Marqo server instance:

docker pull marqoai/marqo:latest
docker rm -f marqo
docker run --name marqo -it -p 8882:8882 marqoai/marqo:latest

Setting up Marqo Client (in Python)

pip install marqo

Note:

If you're using Marqo 2.0.0, you'll need to use marqo1 package.
Find more detailed instructions on setting up Marqo here.

Code Walkthrough

In this section, we will go through implementation steps and code snippets for Multilingual image search with Marqo.

Initializing Search Index

Firstly, we initialize the Marqo search index with the desired settings.

Code Snippet

import marqo

def initialize_search_index(client_url, index_name, settings):
    # Initialize Marqo client with the provided URL
    mq = marqo.Client(url=client_url)
    try:
        # Attempt to create a new search index with specified settings
        mq.create_index(index_name, settings_dict=settings)
    except marqo.errors.MarqoWebError as e:
        # Check if index already exists to avoid duplication
        if e.code == 'index_already_exists':
            print(f"Index {index_name} already exists. Skipping creation.")
        else:
            # Raise other exceptions
            raise
    return mq

Explanation

Client Initialization: Establishes connection to Marqo server.
Index Creation: Tries to create a new index; handles case where index already exists.

Populating the Index with Image Data

We populate the index with images and their descriptions in multiple languages (English & Spanish).

Code Snippet

def populate_index_with_images(mq, index_name, image_data):
    # Add image data to the specified index
    return mq.index(index_name).add_documents(
        image_data,
        tensor_fields=['description', 'description_es'],  # Fields for dense retrieval
        device="cpu",  # Specify the device for processing (CPU in this case)
        client_batch_size=1  # Process data in individual batches
    )

Explanation

Document Addition: Adds images and descriptions to the index.
Tensor Fields: Fields used for embedding and retrieval.
Batch Processing: Efficient data ingestion in batches.

Performing Searches in Different Languages

This step involves searching the index using queries in multiple languages.

Code Snippet

def perform_search(mq, index_name, query_text, language_code):
    # Choose the search field based on language code
    search_field = "description_es" if language_code == "es" else "description"

    # Perform the search with the given query
    search_results = mq.index(index_name).search(
        q=query_text,
        attributes_to_retrieve=[search_field, "url"],  # Fields to retrieve in results
        limit=1  # Limit the number of results
    )
    return search_results

Explanation

Field Selection: Dynamically selects the search field based on language (description_es, description).
Executing Query: Searches the index with the specified query and retrieves relevant fields.

Displaying Search Results

Finally, we extract and display image URLs from the search results.

Code Snippet

def display_image_urls(search_results):
    # Iterate through each hit in the search results
    for hit in search_results.get('hits', []):
        # Print the URL of the image
        print(hit.get('url'))

Explanation

Result Iteration: Loops through each hit in the results.
URL Display: Outputs the URL of each image.

Putting It All Together (Example Implementation)

This section demonstrates the main function, which ties the previously discussed functionalities into a complete workflow, implementing a client for this functionality.

Code Snippet

def main():
    client_url = "http://localhost:8882"
    index_name = "multilingual-image-search"
    settings = {
        "treatUrlsAndPointersAsImages": True,
        "model": "multilingual-clip/XLM-Roberta-Large-Vit-L-14",
        "normalizeEmbeddings": True,
    }

    # Initialize Marqo client and index
    mq = initialize_search_index(client_url, index_name, settings)

    # Image data format: List of dictionaries, each with 'url', 'description', and 'description_es'
    image_data = [
        # Example:
        # {"url": "http://example.com/image1.jpg", 
        #  "description": "Description in English", 
        #  "description_es": "Descripción en español"}
        # ... [Add your image data with descriptions here] ...
    ]

    # Populate the index with images
    populate_index_with_images(mq, index_name, image_data)

    # Perform searches in different languages
    english_results = perform_search(mq, index_name, "A streetwise ape with a flair for the dramatic", "en")
    spanish_results = perform_search(mq, index_name, "Un simio callejero con un sentido dramático", "es")

    # Print and display search results
    print("Search results for English query:", english_results)
    print("Search results for Spanish query:", spanish_results)

    print("\nImage URL from English query:")
    display_image_urls(english_results)

    print("\nImage URL from Spanish query:")
    display_image_urls(spanish_results)

if __name__ == '__main__':
    main()

Explanation

Initialization: Sets up the client URL and index name, and defines the index settings.
Index Population: Loads the image data into the Marqo index.
Search Execution: Performs searches using English and Spanish queries.
Result Display: Outputs the search results and displays the image URLs.

Note: Find the full implementation on Github.

Best practices and Optimization techniques

Optimize Index Settings

Select the Right Model: Choose a model that best fits your dataset. For instance, multilingual-clip/XLM-Roberta-Large-Vit-L-14 is ideal for diverse linguistic content.
Normalization: Use the normalizeEmbeddings setting for more accurate distance measurements in vector space, improving search relevance.

Efficient Data Management

Batch Processing: When populating the index, adjust client_batch_size based on your system's capabilities to balance between speed and resource usage.
Regular Index Updates: Keep your index up-to-date with new images and descriptions to maintain search relevance and accuracy.

Handle Multilingual Content Effectively

Field Mapping: Use language-specific fields (like description_es for Spanish) to store and retrieve language-specific content.
Language Detection: Implement automatic language detection in your application to choose the appropriate search field dynamically.

Performance Tuning

Hardware Utilization: If using a GPU, ensure Marqo is configured correctly to leverage it, significantly speeding up indexing and search operations.
Query Optimization: Refine your queries based on user feedback and search patterns. Short, concise queries often yield better results.

Utilize Marqo's Advanced Features

Synonyms and Stopwords: Explore advanced features like synonyms and stopwords to refine the search experience.
Custom Ranking: Use custom ranking parameters to tailor search results based on specific criteria like popularity or recency.

Use Cases for Multilingual Image Search

Multilingual image search powered by Marqo offers specialized applications across many industries. Let's explore some specific use cases:

E-Commerce

Global Product Discovery: Online shoppers from different regions can search for products like red evening dress or 晚礼服 in their native languages, significantly enhancing user experience.
Localized Marketing: Retailers can present products with images that resonate culturally with each linguistic market, like showcasing traditional attire in searches from specific regions.
Customer Reviews and Q&A: Multilingual search can help in navigating through customer reviews and questions in various languages, aiding in informed purchase decisions.

Stock Photo Libraries

Broad Accessibility: Photographers can tag their work in multiple languages, enabling users worldwide to discover relevant images, like searching for 日出 or sunrise to find similar thematic content.
Cultural Archives: Stock libraries can serve as digital archives, preserving cultural imagery that's searchable in multiple languages, thus aiding cultural preservation and education.

Media and Entertainment

Targeted Content Distribution: Distributors can use multilingual image search to categorize films or shows based on culturally relevant themes, optimizing content for different linguistic audiences.
Promotional Campaigns: Movie studios can create promotional campaigns with imagery that resonates differently with each language-speaking audience, enhancing global reach and relatability.

Conclusion and External References

Recap & Key Points

In this guide, we explored the implementation of multilingual image search using Marqo, starting from the System Requirements and installation, to a detailed code walkthrough.

We emphasized on best practices, error handling, and optimization strategies to enhance search performance. The exploration of diverse use cases across sectors like e-commerce, stock photos, and Media & Entertainment highlighted the versatility and impact of Marqo.

Further Exploration

To explore Marqo further, here are some valuable resources:

Marqo Documentation: Dive deeper into Marqo's capabilities and features by visiting Marqo's official documentation.
Multilingual CLIP Models: Understand the underlying models used in Marqo for multilingual search by reading about Multilingual CLIP models.
Community and Support: Engage with the Marqo community and seek support for specific issues on GitHub.
Case Studies and Articles: Gain insights from practical implementations and case studies, such as the Medium article on implementing text-to-image search using Marqo.