"ConnectionStrings": 
    {
        "Default": 
        "Server=localhost;Database=BookStore;Trusted_Connection=True"
    }  

dotnet run

yarn

yarn start

using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Data.SqlClient;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
        
    namespace Acme.BookStore.Data
     {
        
      public class SQLHelperUtilityClass
        {
            public static void AddTenantWiseDbToElasticPool(string dbName)
             {
                SqlConnection conn = new SqlConnection("Data Source=localhost;" + "Initial Catalog=dbname;" + "User ID=userid;" + "Password=pass;" + "Connection Timeout=3600");
                try
                {
                    SqlCommand cmd = new SqlCommand("add_db_elastic_pool", conn);
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = "CREATE DATABASE " + dbName + " ( SERVICE_OBJECTIVE = ELASTIC_POOL (name = elasticpoolname ));";
                    conn.Open();
                    cmd.ExecuteNonQuery();
                    conn.Close();
                }
                    catch (Exception ex)
                    {
                        if (conn.State == ConnectionState.Open)
                        {
                            conn.Close();
                        }
                    }
                }
        }

private async Task<string> GetDBName(string connectionString)
    {
        try
        {
            await Task.Yield();
            string[] stringSeparators = connectionString.Contains("Initial Catalog") == true ? new string[] { "Initial Catalog=", ";Persist Security " } : new string[] { "Database=", ";Persist Security " };
            string[] firstNames = connectionString.Split(stringSeparators, StringSplitOptions.TrimEntries);
            return firstNames[1];
        }
        catch (Exception ex)
        {
            _logger.LogException(ex);
            return "";
        }
    }
    

string connectionString = tenantConfiguration.ConnectionStrings.FirstOrDefault().ToString();
    foreach (var migrator in _dbSchemaMigrators)
        {
            await migrator.MigrateAsync();
            string dbName = await GetDBName(connectionString);                                              
            SQLHelperUtilityClass.AddTenantWiseDbToElasticPool(dbName);  
        } 

        
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Volo.Abp.Data;
using Volo.Abp.DependencyInjection;
using Volo.Abp.EventBus.Distributed;
using Volo.Abp.Identity;
using Volo.Abp.MultiTenancy;
using Volo.Abp.Uow; 
namespace Acme.BookStore.Data; 
public class BookStoreTenantDatabaseMigrationHandler :
    IDistributedEventHandler<TenantCreatedEto>,
    IDistributedEventHandler<TenantConnectionStringUpdatedEto>,
    IDistributedEventHandler<ApplyDatabaseMigrationsEto>,
    ITransientDependency
{
    private readonly IEnumerable<IBookStoreDbSchemaMigrator> _dbSchemaMigrators;
    private readonly ICurrentTenant _currentTenant;
    private readonly IUnitOfWorkManager _unitOfWorkManager;
    private readonly IDataSeeder _dataSeeder;
    private readonly ITenantStore _tenantStore;
    private readonly ILogger<BookStoreTenantDatabaseMigrationHandler> _logger; 
    public BookStoreTenantDatabaseMigrationHandler(
        IEnumerable<IBookStoreDbSchemaMigrator> dbSchemaMigrators,
        ICurrentTenant currentTenant,
        IUnitOfWorkManager unitOfWorkManager,
        IDataSeeder dataSeeder,
        ITenantStore tenantStore,
        ILogger<BookStoreTenantDatabaseMigrationHandler> logger)
    {
        _dbSchemaMigrators = dbSchemaMigrators;
        _currentTenant = currentTenant;
        _unitOfWorkManager = unitOfWorkManager;
        _dataSeeder = dataSeeder;
        _tenantStore = tenantStore;
        _logger = logger;
    } 
        public async Task HandleEventAsync(TenantCreatedEto eventData)
    {
        await MigrateAndSeedForTenantAsync(
        eventData.Id,
        eventData.Properties.GetOrDefault("AdminEmail") ?? BookStoreConsts.AdminEmailDefaultValue,
        eventData.Properties.GetOrDefault("AdminPassword") ?? BookStoreConsts.AdminPasswordDefaultValue
        );
    } 
        public async Task HandleEventAsync(TenantConnectionStringUpdatedEto eventData)
    {
        if (eventData.ConnectionStringName != ConnectionStrings.DefaultConnectionStringName ||
        eventData.NewValue.IsNullOrWhiteSpace())
    {
        return;
    } 
        await MigrateAndSeedForTenantAsync(
        eventData.Id,
        BookStoreConsts.AdminEmailDefaultValue,
        BookStoreConsts.AdminPasswordDefaultValue
    ); 
        /* You may want to move your data from the old database to the new database!
        * It is up to you. If you don't make it, new database will be empty
        * (and tenant's admin password is reset to 1q2w3E*).
        */
    } 
        public async Task HandleEventAsync(ApplyDatabaseMigrationsEto eventData)
    {
        if (eventData.TenantId == null)
    {
        return;
    } 
        await MigrateAndSeedForTenantAsync(
        eventData.TenantId.Value,
        BookStoreConsts.AdminEmailDefaultValue,
        BookStoreConsts.AdminPasswordDefaultValue
        );
    } 
        private async Task MigrateAndSeedForTenantAsync(
        Guid tenantId,
        string adminEmail,
        string adminPassword)
    {
        try
    {
        using (_currentTenant.Change(tenantId))
    {
        // Create database tables if needed
        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: false))
    {
        var tenantConfiguration = await _tenantStore.FindAsync(tenantId);
        if (tenantConfiguration?.ConnectionStrings != null &&
        !tenantConfiguration.ConnectionStrings.Default.IsNullOrWhiteSpace())
    {
        //string connString = "Server=WAILAP173\SQLEXPRESS;Initial Catalog=BookStoreProjectDem0;Persist Security Info=False;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=3600;";
        string connectionString = tenantConfiguration.ConnectionStrings.FirstOrDefault().ToString();
        foreach (var migrator in _dbSchemaMigrators)
    {
        await migrator.MigrateAsync();
        string dbName = await GetDBName(connectionString);
        SQLHelperUtilityClass.AddTenantWiseDbToElasticPool(dbName);
    }
    }
        await uow.CompleteAsync();
    } 
        // Seed data
        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
    {
        await _dataSeeder.SeedAsync(
        new DataSeedContext(tenantId)
        .WithProperty(IdentityDataSeedContributor.AdminEmailPropertyName, adminEmail)
        .WithProperty(IdentityDataSeedContributor.AdminPasswordPropertyName, adminPassword)
        ); 
        await uow.CompleteAsync();
    }
    }
    }
        catch (Exception ex)
    {
        _logger.LogException(ex);
    }
    }   
        private async Task<string> GetDBName(string connectionString)
    {
        try
    {
        await Task.Yield();
        string[] stringSeparators = connectionString.Contains("Initial Catalog") == true ? new string[]
    { 
        "Initial Catalog=", ";Persist Security " } : new string[] { "Database=", ";Persist Security " };
        string[] firstNames = connectionString.Split(stringSeparators, StringSplitOptions.TrimEntries);
        return firstNames[1];
    }
        catch (Exception ex)
    {
        _logger.LogException(ex);
        return "";
    }
    }
}