Hevo Data

hevodata

PostgreSQL their latest version (PostgreSQL 14) on September 30th, which includes a bunch of features like pipeline API, gathering statistics on replication slots, query parallelism improvements and so on. While the of PostgreSQL can be traced back to 1986, it has been in active development for the past 30 years. Tons of companies, agnostic of the type and size, have trusted Postgres over the years and their tagline “The world's most advanced open-source relational database” is hardly an overstatement. announced origin In a typical, non-trivial system, there is more than one database server, and the data is often copied across multiple servers. A fairly common notion in a distributed system, this copying of data across multiple server nodes is known as replication. Replication processes are often abstracted from the consumers of the database, so most of the application layers are transparent to which node serves the data and if you’re an app developer like me, we expect things to “just work”. However, what goes behind the scenes of some of the most sophisticated databases of the world is often a fascinating reading and learning experience. In this post, we will start diving into the internals of Postgres to understand how replication works and data integrity is ensured using WAL (Write-Ahead Logging). We will then steer towards interesting concepts like logical decoding and output plugins. Finally, we will start hacking some code to write our own plugin that can send push notifications! I know this sounds a bit contrarian to the common approach of sending notifications from application servers, but hey what's the fun in doing common boring things! Let's dive right in :) Replication at a high level is the process of transferring data from a primary server to a replica server. In Postgres lingo, servers can either be primary or stand-by. Primary servers are the ones that send data, while standbys are the receivers of replicated data. In certain settings, standbys can also act as senders. Replica or standby servers can take over if the primary fails which is the crux of how database systems manage fault tolerance. https://www.enterprisedb.com/postgres-tutorials/postgresql-replication-and-automatic-failover-tutorial#replication WAL (Write-Ahead Logging) is the standard method to ensure data integrity in Postgres. Systems are bound to fail and database servers are not excused from that. At the application layer, it's comparatively easier to retry and manage failures without typically resulting in data loss, however, when we go deep in the stack, especially at the data layer, persistence is doubtlessly super critical. When consumers make a write operation to the database, before the database is acted-upon, the changes are written to the server’s file system. This by design ensures data persistence and recovery in the cases of operating system crashes or hardware failures. Consumers are (obviously) abstracted from these internal mechanisms and applications connected to the Database expect things to work out of the box. The log entry we talked about above is known as the Write-Ahead Log record while the process is called Write-Ahead Logging. Each record has a Sequence number which is used for checkpointing periodically after logs are synchronized to the database. In cases of system crashes, this checkpoint is used to re-read and synchronize. WAL, being a reliable method for synchronizing or recreating the ordered state of the database, is used for replication across multiple servers. WAL can replicate the data using either a File based approach or a Streaming approach where both approaches have their own pros and cons. Streaming replication, although is typically in an asynchronous mode, can be tuned to be synchronous. https://hevodata.com/learn/postgres-wal-replication/ WAL records being representative of the internal state of the Database system, are not easy to be fed into or understood by an external system/consumer. Logical Decoding to the rescue! “ is the process of extracting all persistent changes to a database's tables into a coherent, easy to understand format which can be interpreted without detailed knowledge of the database's internal state.” Using logical decoding, replication solutions and auditing can be achieved much easily. Logical decoding The following diagram depicts the logical decoding process. Source: https://techcommunity.microsoft.com/t5/azure-database-for-postgresql/change-data-capture-in-postgres-how-to-use-logical-decoding-and/ba-p/1396421 In order to enable the logical decoding, you need to make some configuration changes to the Postgres instance - wal_level = logical # default value is `replica`
max_replication_slots = 1 # good enough for a sample project
max_wal_senders = 1 # default is 10 Ref: and for details on tuning the configuration https://www.postgresql.org/docs/current/runtime-config-replication.html https://www.postgresql.org/docs/current/runtime-config-wal.html Once we have the configuration up and running, record changes are passed to the Output Plugin which does the key step of transformation from the WAL format to the format specified in the plugin (eg. JSON). These changes are made available on the replication slot(s) and consumer applications can receive the stream of updates as and when those occur. Some output plugins and consumer apps out there - Output Plugin that converts WAL output to JSON objects [Open Source] Postgres app that can consume update stream [Out-of-the-box with Postgres]
decoderbufs Output Plugin that delivers data as protobuf [Open Source, Used in ] wal2json pg_recvlogical Debezium We can write a consumer from scratch or use battle-tested tools built to achieve this at scale. Debezium is one of the most widely used solutions out there. Netflix open sourced their in-house tool for CDC called DBLog - is a fantastic read on it. https://netflixtechblog.com/dblog-a-generic-change-data-capture-framework-69351fb9099b What are we building? Let’s keep this simple - whenever a new user entry is made to Postgres table, we will consume replication logs and send a welcome email to the user. Let’s hack some code! We will be using a Go package which is a Postgres logical replication library. https://github.com/jackc/pglogrepl Step 1: Follow Logical replication instructions README has step-by-step instructions to configure logical replication in your local Postgres Instance. https://github.com/jackc/pglogrepl Step 2: Try out the demo in the repo Give a try - it demos how the library works under the hood https://github.com/jackc/pglogrepl/tree/master/example/pglogrepl_demo Step 3: Update the demo code to log new email inserts To keep it simple for this blog post, let's add some code that prints out a specific email that was inserted on the new row. A.  Look for inserts and print the WAL data if logicalMsg.Type() == 'I' {
   // `I` stands for Insert
   log.Println(string(xld.WALData))
   // this logs the complete entry
   // however it would require a little more cleanup
} For example, a new entry with ID 5 and email shows up as I@Nt5ttejas@courier.com tejas@courier.com B. Clean up the internal WAL representation and derive email // find the second column
  walData := xld.WALData[5:]
  pos := bytes.Index(walData, []byte("t"))

  email := walData[pos+1:]
  pos = bytes.Index(email, []byte("t"))

  email = email[pos+1:]
  emailStr := string(email) C. Send a welcome email to the user We will be creating a new template by configuring an email integration supported by Courier. messageID, err := client.Send(context.Background(), "VDPE8SWN1K4BWMP8RJ101YRZTF3J", "user-id", 
courier.SendBody{
   	Profile: profile{
   	   Email: emailStr,
   	},
   	Data: data{
   	   Foo: "bar",
   	},
})

if err != nil {
  log.Fatalln(err) 
}

log.Println(messageID) Find the modified code at Here’s a quick of how things work. https://github.com/tk26/pglogrepl loom video Now that we have configured Postgres to send emails by listening to replication logs, changing it to send a push notification would be as simple as changing a configuration in the Courier Studio. Thanks for reading! Reach out to us if you have any questions or comments or you know, just say Hi! @trycourier

Hacking PostgreSQL Internals to Deliver Push Notifications

How to Structure Your K8s GitOps Repository at Scale [Part 1]

Optimizing CRUD Operations in Flutter: How to Implement HTTP Requests with Dio

Just an Intro Arrays and linked lists are two of the most fundamental data structures in computer science. They both have their advantages and disadvantages, and knowing when to use one over the other can make a big difference in the efficiency of your code. In this article, we'll explore some common use cases for both arrays and linked lists and how they apply in the real world. Arrays: Fast & Furious Arrays are one of the simplest and most widely used data structures in programming. They are essentially a collection of items that are stored in contiguous memory locations. This makes accessing and manipulating individual elements in an array very fast and efficient. Arrays also have a fixed size, which means that they are perfect for storing a known number of items. It is worth noting that in some languages, like python, we have dynamic arrays so size is not always fixed. One of the most common use cases for arrays is in storing and processing large amounts of data. For example, if you were building a weather forecasting application for a city in Africa, you might use an array to store daily temperature readings for the past year. This would allow you to quickly access and manipulate individual temperature values for a particular day or range of days. Another example of where arrays can be useful in Africa is in sorting large amounts of data. If you were building a logistics application to track the movement of goods across the continent, you might use an array to store the location and status of each shipment. This would allow you to quickly sort and filter shipments based on their current status, such as "in transit" or "delivered." Arrays are also very efficient when it comes to adding or removing elements at the end of the collection, which is known as an append operation. This is because appending to an array simply involves updating the size of the array and copying the new element to the end. However, adding or removing elements in the middle of an array can be much slower, as it requires shifting all the subsequent elements by one position. Linked Lists: Flexible and Adaptable Linked lists are a more complex data structure that can be used in situations where the size of the collection is not known in advance or where elements need to be added or removed frequently. A linked list consists of a sequence of nodes, each containing a value and a pointer to the next node in the list. This makes linked lists more flexible than arrays, as they can be easily resized and modified without needing to move large amounts of data around. One example of where linked lists might be useful is in managing healthcare records for a large hospital or clinic. Patients may need to be added or removed from the system at any time, and their medical history and treatment information may need to be updated frequently. A linked list would allow healthcare providers to easily add or remove patient records and modify their medical information as needed. Another example of where linked lists can be useful is in building a social network or messaging application. In these types of applications, users may need to be added or removed from the system at any time, and messages may need to be added or removed from their conversation threads. A linked list would allow you to easily add or remove users and messages and keep track of the order in which they were added. Linked lists also have some advantages over arrays when it comes to memory usage. Because linked lists only allocate memory for the nodes that are currently in use, they can be more memory-efficient than arrays for collections that are not always fully populated. class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None
        
class LinkedList:
    def __init__(self):
        self.head = None
        
    def append(self, data):
        new_node = Node(data)
        
        if self.head is None:
            self.head = new_node
            return
        
        current_node = self.head
        while current_node.next is not None:
            current_node = current_node.next
        
        current_node.next = new_node
        
    def insert(self, data, position):
        new_node = Node(data)
        
        if position == 0:
            new_node.next = self.head
            self.head = new_node
            return
        
        current_node = self.head
        current_position = 0
        
        while current_node.next is not None and current_position < position - 1:
            current_node = current_node.next
            current_position += 1
        
        new_node.next = current_node.next
        current_node.next = new_node
        
    def delete(self, data):
        if self.head is None:
            return
        
        if self.head.data == data:
            self.head = self.head.next
            return
        
        current_node = self.head
        while current_node.next is not None and current_node.next.data != data:
            current_node = current_node.next
        
        if current_node.next is not None:
            current_node.next = current_node.next.next
            
    def print_list(self):
        current_node = self.head
        while current_node is not None:
            print(current_node.data)
            current_node = current_node.next Conclusion In conclusion, the choice between using an array or a linked list depends on the specific requirements of your application. Arrays are best suited for situations where the size of the collection is known in advance and where elements need to be accessed or manipulated quickly. Linked lists are more flexible and adaptable and are best suited for situations where the size of the collection is not known.

Arrays vs. Linked Lists: Which Is Better?

This is a simple NodeJS app that takes a source folder as input and generates a Bash script. The Bash script has all the files' content and the folders' structure in the source folder, and it can recreate them when executed. Source code available here: https://github.com/alexadam/folders-to-script First step, iterate through all files in the source folder: const fs = require("fs")
const path = require("path")

const listFiles = (dirPath, result) => {
 files = fs.readdirSync(dirPath)

 result = result || ['#!/bin/sh']

 for (const file of files) {
   ///...
 }

 return result
}

const allFiles = listFiles(rootPath)

fs.writeFileSync('./result.sh', allFiles.join('\n')) If is a directory, add an command: file mkdir -p for (const file of files) {
 if (fs.statSync(dirPath + "/" + file).isDirectory()) {
 result.push(`mkdir -p ${path.join(dirPath, "/", file).replace(rootPath, '.')}`)
 result = listFiles(dirPath + "/" + file, result)
 } 
} Else, test if is binary or text, based on its extension: file const textExt = ['txt', 'md', 'html', 'json', 'js', 'jsx', 'ts', 'tsx'];
const binaryExt = ['jpg', 'png', 'gif', 'pdf', 'mp3', 'mp4'];

const getFileExt = (filePath) => filePath.split('.').pop()

...
    else {
      const filePath = path.join(dirPath, "/", file);
      const fileExt = getFileExt(filePath);
      const fileContent = fs.readFileSync(filePath);

      if (textExt.includes(fileExt)) {
        result.push(`
cat > ${path.join(dirPath, "/", file).replace(rootPath, '.')} << "EOF"
${fileContent}
EOF
`)
      } else if (binaryExt.includes(fileExt)) {
        const bindata = fileContent.toString('binary');
        const hexdata = new Buffer(bindata, 'ascii').toString('hex');
        result.push(`echo '${hexdata}' | xxd -r -p > ${path.join(dirPath, "/", file).replace(rootPath, '.')}`)
      }
    }
... Binary files are stored as hex strings. You can add/remove file extensions in the or arrays. textExt binaryExt This is the full NodeJS script: const fs = require("fs")
const path = require("path")

const rootPath = process.argv[2]

const textExt = ['txt', 'md', 'html', 'json', 'js', 'jsx', 'ts', 'tsx'];
const binaryExt = ['jpg', 'png', 'gif', 'pdf', 'mp3', 'mp4'];

const getFileExt = (filePath) => filePath.split('.').pop()

const listFiles = (dirPath, result) => {
  files = fs.readdirSync(dirPath)

  result = result || ['#!/bin/sh']

  for (const file of files) {
    if (fs.statSync(dirPath + "/" + file).isDirectory()) {
      result.push(`mkdir -p ${path.join(dirPath, "/", file).replace(rootPath, '.')}`)
      result = listFiles(dirPath + "/" + file, result)
    } else {
      const filePath = path.join(dirPath, "/", file);
      const fileExt = getFileExt(filePath);
      const fileContent = fs.readFileSync(filePath);

      if (textExt.includes(fileExt)) {
        result.push(`
cat > ${path.join(dirPath, "/", file).replace(rootPath, '.')} << "EOF"
${fileContent}
EOF
`)
      } else if (binaryExt.includes(fileExt)) {
        const bindata = fileContent.toString('binary');
        const hexdata = new Buffer(bindata, 'ascii').toString('hex');
        result.push(`echo '${hexdata}' | xxd -r -p > ${path.join(dirPath, "/", file).replace(rootPath, '.')}`)
      }
    }
  }

  return result
}

const allFiles = listFiles(rootPath)

fs.writeFileSync('./result.sh', allFiles.join('\n')) Test it with -> it will generate a Bash script file named node index.js test result.sh Then, in an empty directory, execute the script with . sh result.sh Also published on . https://alexadam.dev/blog/folder-structure-script.html

How to Generate Bash Scripts with NodeJS

Dandy and Flirt

Creating a router allows you to take complete control when handling certain incoming requests to your site. This article takes you through what code you have to write in order to make your router work. To learn more about what a router is and why you would want to create one, see . About Routers Add a Router To add a router: 1. Click on the icon that appears when hovering over the Page Code's Main Pages section in the and choose . Velo Sidebar Add a Router 2. Enter a for your router and click . All incoming requests with the specified URL prefix will be sent to your router for handling. URL prefix Add & Edit Code When adding a router: Your router's and functions are added in a file with sample code for a simple routing scenario. The file is found in the Code Files's Backend section of the Velo Sidebar. router() sitemap() routers.js routers.js A new section, Router Pages, is created in the Velo Sidebar for your routers. Router pages are grouped together under a title based on the prefix you chose earlier. One router page is created to start with. For example, if you named your router "myRouter", a page named is added under the title . myRouter-page MyRouter Pages (Router) Sample Scenario There are four parts to the sample code that's added to the file: routers.js The statement. import The sample data. The function. router() The function. sitemap() Import statement The functionality used to create a router is contained in the . To use this functionality, you need to import it. By default, the and functions are imported, as well as the object. Router API ok() notFound() WixRouterSitemapEntry {ok, notFound, WixRouterSitemapEntry} ; import from "wix-router" If you want to use more of the functionality from the Router API, you need to add it to the statement. import Sample Data In the sample scenario, the router uses some static data contained in an object named . peopleData peopleData = { : { : , : }, : { : , : }, : { : , : }, : { : , : }
}; const "Ash" title "Ash Stowe" image "https://static.wixstatic.com/media/b8f383e0fe2b478ea91362b707ef267b.jpg" "Aiden" title "Aiden Johnson" image "https://static.wixstatic.com/media/ca3c7ac5427e43928aa5f3f443ae2163.jpg" "Jess" title "Jess White" image "https://static.wixstatic.com/media/147fe6f37fe24e83977b4124e41b6d3d.jpg" "Morgan" title "Morgan James" image "https://static.wixstatic.com/media/59e1f2f4dbbc4f7c9d6e66e3e125d830.jpg" The object contains four keys, each representing a person. Each person contains two properties, a that is the person's full name and an that is a link to an image of the person. peopleData title image Although you can use static data with a router, typically you would use data from your site's database or an external source. We'll see where you would write code to retrieve that data a little later. Regardless of where you get the data from, since you'll be writing the code that handles it, the data can be structured in any way you like. Router Function Remember, all incoming requests with the URL prefix you specified when creating the router are sent to your router for handling. The function is where you handle those requests. router() The function is named with the following convention: router() <router prefix>_Router(request) So if you named your router , the code added to the file should look like: myRouter routers.js myRouter_Router(request) { // routing code ...} The function has a request parameter which receives a object that contains information about the incoming request. The object has information about the URL used to reach the router, where the request came from, and who the request came from. router() WixRouterRequest Typically, the function will decide which page to show (if any) and what data to pass to the page. A response is then sent using the , , , , functions. router() forbidden() notFound() ok() redirect() or sendStatus() Let's take a look at the sample function code: router() { name = request.path[ ]; data = peopleData[name]; (data) { seoData = { : data.title, : , : , : [
         { : data.title, : data.image, : }
      ]
    }; ok( , data, seoData); 
  } notFound();
} export ( ) function myRouter_Router request // Get item name from URL request const 0 // Get the item data by name const if //define SEO tags const title description `This is a description of page` ${data.title} noIndex false metaTags "og:title" "og:image" content "People Data" // Render item page return "myRouter-page" // Return 404 if item is not found return The function begins by parsing the request's path to pull out a name value. router() name = request.path[ ]; const 0 For example, a user might reach this function by browsing to . The received object's property will be an array with one element: . Now the value of name is " ". router() https://mysite.com/myRouter/Ash WixRouterRequest path ["Ash"] Ash Next, the function retrieves data based on the it received. router() name data = peopleData[name]; const Continuing our example above, we pull out Ash's information from the object. peopleData So now holds: data { : , : } title "Ash Stowe" image "https://static.wixstatic.com/media/b8f383e0fe2b478ea91362b707ef267b.jpg" If you want to retrieve data from an external source, this is where you place the call to retrieve that data. After attempting to retrieve the data that corresponds to the incoming request, we check to see if any data was found: (data) { } if // ... If nothing was found, the is skipped and we return a 404 error using the function. if notFound() notFound(); return Assuming we found the data we were looking for, we now prepare some header data for our page: seoData = { : data.title, : , : , : { : data.title, : data.image
  }
}; const title description `This is a description of page` ${data.title} noIndex false metaTags "og:title" "og:image" Here we create a object that defines what will be put in the HTML head of the page we respond to the request with. That object is stored in the seoData variable. HeadOptions The sample code creates a and based on the property of the retrieved object. It also sets to false, meaning search engines should index the page. Finally, some properties are added as well. title description title data noIndex metaTags You can create the object using any information you want. HeadOptions You can also add a keywords property to the object with a string containing the page's keywords. HeadOptions Finally, we return a object using the function: WixRouterResponse ok() ok( , data, seoData); return "myRouter-page" Here we route the user to the router page named " " and pass it the that was retrieved and the that was built for the page. myRouter-page data seoData Depending on the situation, you can return a number of different responses from the function. So far we've seen the and functions in use. You can also use the function to return a response, the function to return a or response, or the function to return a response with any status code you choose. router() notFound() ok() forbidden() 403 redirect() 301 302 sendStatus() Router Data To use the data that was returned with a using the function, use the window function. WixRouterResponse ok() wix- getRouterData() For example, we can take the data passed by the sample router code and use it to present a person's information on the page that was created. myRouter-page First, we need to add a text and image element to serve as placeholders for a person's title and image. Next, in the page's code we retrieve the router data and set the text and image elements to display the and from the data. title image wixWindow ;

$w.onReady( { data = wixWindow.getRouterData();
  $w( ).text = data.title;
  $w( ).src = data.image;
}); import from 'wix-window' ( ) function let "#text1" "#image1" If you preview the page, you'll see that the placeholders we put on the page are filled in with information from the data that was passed to the page. You can use the preview widget to see what the page looks like for any of the people in the object that was defined in the file. peopleData routers.js The preview widget gets populated with the values from the objects that are returned by the router's function. title WixRouterSitemapEntry sitemap() Sitemap Function Like the function, the function is named with the following convention: router() sitemap() <router prefix>_Sitemap(sitemapRequest) So if you named your router , the code added to the file should look like: myRouter routers.js myRouter_Sitemap(sitemapRequest) { // routing code ...} The function has a parameter which receives a object that contains information about the incoming request. The object has information about the URL used to reach the router, the pages in the router, and who the request came from. sitemap() sitemapRequest WixRouterSitemapEntry Typically, the function creates a object for each item in the data used by the router. So, in our example, we create an entry for each person in the object. You also might want to include entries for other pages, like an index page or a search page. sitemap() WixRouterSitemapEntry personData Let's take a look at the sample function code: sitemap() { siteMapEntries = .keys(peopleData).map( { data = peopleData[name]; entry = WixRouterSitemapEntry(name);
    entry.pageName = ; entry.url = ; entry.title = data.title; entry;
  } ); siteMapEntries;
} export ( ) function myRouter_SiteMap sitemapRequest // Convert the data to site map entries const Object ( ) => name const const new "myRouter-page" // The name of the page in the Wix Editor to render `/myRouter/ ` ${name} // Relative URL of the page // For better SEO - Help Google return // Return the site map entries return The function takes the keys of the peopleData object and uses the JavaScript function to create an array of objects, one object for each key. Each entry is given values for the , , and properties. Then the array is wrapped in a and returned. sitemap() map() WixRouterSitemapEntry pageName url title Promise A sitemap entry can also contain , , and properties to give search engines more information about each page. changeFrequecy lastModified priority In a case where you're using a router with external data, in the function you would retrieve that data and build sitemap entries for each item that was retrieved. sitemap() Previously published at https://support.wix.com/en/article/velo-creating-a-router

Creating and Debugging Website Routers 

SEO Settings for pages vary slightly from the settings for regular pages. Learn about SEO for Wix pages . router here You can define the page title, description, and social network images for router pages just like you can for regular pages. The difference is that since router pages do not contain static data, their SEO information must be set dynamically, so they reflect the real content they will hold when they are viewed. There are two parts to setting up SEO on your router pages: Create meta tags for Google to learn about your pages. Create a sitemap for Google to use to find your pages. Meta Tags You set SEO meta tags for your router's pages when you . Within that function, you create a object and pass it to the page you route to using the function. create the router's router() function HeadOptions ok() For example, in the sample code that is provided when you add a router, the following code uses the data retrieved by the router to build a HeadOptions object and pass it to the page named . myRouter-page { seoData = { : data.title, : + data.title + , : , : { : data.title, : data.image
    }
  }; ok( , data, seoData); } export ( ) function myRouter_Router request // retrieve data for the page ... let title description "This is a description of " " page" noIndex false metaTags "og:title" "og:image" return "myRouter-page" //... The object contains several properties that you can set with relevant values using the data you retrieve in your function. The and properties contain the page's title and description that are used for SEO purposes. The object can also contain a flag that tells Google whether it should index your page. Additional meta tags can be added to the property. HeadOptions router() title description noIndex metaTags The object can also contain a keywords property, but Google ignores your site's keywords. HeadOptions Sitemap Your site's sitemap is what Google uses to find all your site's pages. Pages on your site that don't belong to a router are added to your site's sitemap for you. However, since you fully control what pages are available through your router, including all of their dynamically different versions, you need to create a sitemap that contains all possible URLs that are connected to your router's prefix so Google can find them. To add your router's pages to your site's sitemap, you for the router. Within that function, you create a object for each URL the router can possibly route to. Each includes information about a page, such as its URL, title, and name. You can also add additional information about each page, such as how often its content changes, when the last change was, and its relative priority within your site. Google uses the sitemap entries to discover all the pages in your site. create a sitemap() function WixRouterSitemapEntry WixRouterSitemapEntry For example, in the sample code that is provided when you add a router, the following code uses the data retrieved by the router to build a object and pass it to the page named . HeadOptions myRouter-page { siteMapEntries = .keys(peopleData).map( { data= peopleData[name]; entry = WixRouterSitemapEntry(name);
    entry.pageName = ;
    entry.url = + name ;
    entry.title = data.title; entry;
  } ); .resolve(siteMapEntries);
} export ( ) function myRouter_SiteMap sitemapRequest //Convert the data to site map entries let Object ( ) => name const let new "myRouter-page" "/myRouter/" return // Wrap in asynchronic Promise return Promise To ensure that your sitemap is working properly, you can get the sitemap from your published site. In a web browser, go to your published site's URL and append to it. /sitemap.xml For example, for premium sites, if your site's published URL is: https://mysite.com Go to: https://mysite.com/sitemap.xml For free sites, if your site's published URL is: https://username.wixsite.com/site-name Go to: https://username.wixsite.com/site-name/sitemap.xml Previously published at https://support.wix.com/en/article/velo-about-seo-and-routing

Stories, News & Mentions about HEVODATA

Hevodata’s Stories on HackerNoon