Gmail personal account holders have 14 days to wait until new domain authentication rules commence which could see the rejection of millions of emails to better security.

New Gmail Security Rules—You Have 14 Days To Comply, Google Says

If you are looking to experience Android 14&#x27;s predictive back gestures, Gmail is now rolling out an in-app version of it. Check it out!

Gmail now offers an in-app predictive back gesture similar to Android 14

Google has yet to enable system-level Predictive Back in Android 14, but the in-app variant is live in some apps, including Gmail...

Gmail rolls out in-app predictive back on Android 14

AN EYEWATERING £1.3million has fallen into the hands of hackers who have broken into social media and email accounts, new data shows. Action Fraud has revealed that more than 22,500 people had thei…

Millions of Gmail and Facebook users warned to 'secure accounts' as Action Fraud reveals Brits have lost £1.3million | The Sun

UpMail

upmail

So what are GitHub Actions? Github Actions is a free service that can run on a repo when configured. It is similar to which is a CI/CD platform that lets teams build and deliver great software, quickly and at scale, in the cloud, or on your own infrastructure. CircleCI What Can You Do With GitHub Actions? Run shell commands against our repo code (usually Bash on Ubuntu)Use Github’s cloud infrastructureTrigger on an event, like a commit, a Pull Request ( PR), or on a schedule, even on a manual now. button press Importance of GitHub Actions Github Actions takes out the pain of manually running commands on your machine and moves it to the cloud to automated runners. You don’t have to touch your terminal but you’ll get a log of steps that is centralized and public — nice to share across your team or open-source contributors. The job runs each pass and fails status and the corresponding commit — so you can track down a bug by seeing the first time your job switched from passing to failing state. You might use Github Actions to build and deploy your package or website, but only if all the safety checks you’ve set up are met. This builds confidence in getting a quality product delivered. Common Terms Workflow Your actions config is a “workflow” of triggers and steps. These steps can be a mixture of: shell commands (like pip install … or npm run build)external actions A workflow file is stored here as a YAML file: .github/workflows/main.yml. Job A workflow is the config file. The job is what actually executes. You can see a history of runs for a single job. You can see runs for the “ CI-CD” job in my Laravel bill-me package repo. here Action You can find an action available in the Actions “marketplace” but really it is a repo that is published by the community and accepted by Github if it meets standards. An action is a packaged, reusable flow which you can use as a library or module. Use it to do more complex tasks in your workflow without writing the code yourself. Note that you don’t to use an action. You can build and test a Laravel app or package using just plain commands as steps. have But if you want more advanced functionality, action is great: Installing and building against using multiple versions of your runtime. Building a Jekyll site or Laravel web app to a GitHub Pages branch to serve on Github Pages . like this one In My Opinion I have enjoyed using GitHub actions as it has let me automate most of my tasks such as running tests and deploying various applications on the server as soon as I push my code to GitHub. Are you a Laravel developer? I will soon publish an article that will show you how you can use Github actions to both run tests and deploy your web application and or package. Thanks for reading the article! If you enjoyed it, please don’t forget to show your appreciation by clicking 👏 below! Before you go… Any questions or comments hit me up: Mail: epmnzava@gmail.com Twitter: https://twitter.com/epmnzava Github: https://github.com/dbrax

Beginner’s Explanatory Guide to GitHub Actions

When Following The Numbers Goes Horribly Wrong Booking.com’s practices and user experience is a great example of what not to follow as a start up. Last week I tried booking.com’s apartment booking for the first time. What happened next lead me to writing this piece that was first titled “How Booking.com’s Horrible UI Tricked Me Out Of $70”. Needless to say I wasn’t thrilled with the results. I have used booking.com for hotels/guest houses and share houses multiple times and never had a complaint. I am even a member of their genius program. So I am very used to the way their website works for booking hotels. What you see is what you get. No hidden fees, no mumbo jumbo. At least that’s what I thought. I assumed Apartments were the same deal, but that’s where I was wrong(and not just me, apparently). Search Page: Seemingly Nothing Wrong What booking.com looks like when searching for apartments. You search apartments, and you can arrange them in whichever way you like. (I prefer score and price, or even lowest price first, as I’m broke, but that’s just me). Nothing wrong here, you think. Then click through on the result that you like, and it shows up like a hotel room, again, there seems to be nothing wrong here. Seemingly. Except, there is something wrong here. Something Fishy Something wrong with the price plastered all over it, in , and even shown in the search. fundamentally 4 different places None of them are the actual price. Booking.com considers the cleaning fee apartment owners have for their listings on booking.com an “excluded fee” (if only that meant that it was “excluded” from my credit card bill), but includes VAT and taxes in the prices listed. But okay, at least when you click through to reserve, the real price of the property will be apparent, right? Actually it gets worse. This is what greeted me above the fold of the booking page: Seems pretty straight forward, right? My price summary, with a nice and big price that seems to summarize the total price I have to pay. What I didn’t notice at the time, was the nasty “excluded charge” section that was , with no attempt whatsoever to stand out or inform me that , which you might want to inform potential customers about, lest they get upset and write a complainy blog post like this. hidden below the fold HEY, THERE’S ACTUALLY A SIZABLE EXTRA CHARGE HERE Not to mention, “excluded charge” sounds more like booking.com is giving me a special deal on a price that normally includes this charge, than a nasty surprise you’re going to tag onto the total without having to mention it before checkout. This is the LAST page where you actually book and commit to staying in a place, and they are still showing very unclear pricing, although finally the cleaning fee appears above the fold. Still horrible user experience. I found an apartment normally listed for ~$200 for about $60 and some change and wanted to treat myself before someone else caught the deal first. (It was a same day booking.) Even in my overview of bookings it shows up for the price I first thought that I got. And this is from the email reminder of my booking: The actual price was in fact not, 6,645 yen or anything even close. The cleaning fee of 8,000 yen pushed the price for the night to 14,645, the price of a night at a pretty good Tokyo hotel, with breakfast included. “Nobody Scammed You, You Are Just An Idiot” I sure felt like an idiot right after it happened. And at first I thought I might be the only one to make this kind of mistake. But then I saw in the follow-up mail from the property. this This is the for this property, and they feel the need to include this to reduce their customer support workload. standard follow up email I am guessing this is something they deal with fairly often. Then I did some Googling, and I found articles like covering the exact same problem, but for multiple sites. this one And honestly even if I was an idiot it’s Booking.com’s literal job to make sure things like this don’t happen often enough for a user of their service to employ a hacky fix like the one shown above, idiot end user or not. Look, I am not trying to make a legal case here that they scammed me out of my hard earned money. This is simply meant as a (because you ran off with my hard-earned cash, go figure) reminder to . not-so-friendly fix your damn user experience Why? How Did Their UX Get Here? So that leads us with the question, why on earth is their UX even like this in the first place? The answer is fairly simple, following the numbers. I am willing to bet my lunch that they simply tested different pricing models, and found that this interface “performed better”. Sure, making it seem like an apartment is cheaper than it is might appear That’s the problem with following the numbers. Sometimes Numbers Don’t Show The Whole Picture You made a change to X and your clickthroughs, conversions and sales are up this month? That doesn’t always automatically mean that keeping that change is the right decision. I might have ended up booking a more expensive place than usual through Booking, giving them a heftier commission, but that’s all peanuts compared to the value of me as a Booking.com user for life, (which is what they lost as a result of this whole interaction). A Note On Customer Service I was at work when I noticed my mistake, and didn’t have the opportunity to wait on the line to reach a customer service rep and then try to argue them into doing the right thing, so I sent a brief message about my problem and that I’d like to cancel if possible, and left it at that. The next day, this is all I got: They obviously didn’t even scan the contents to see what my complaint actually was about, this was just an automated reply informing me that I should have called. I don’t like calling customer service (and I know I’m not the only one), and honestly I shouldn’t have to. The whole process of having people answer phone calls seems a lot more complicated than having someone answer a short message from someone with a confirmed booking in less than 24 hours(not that hard to segment, honestly, it’s 2018). Nobody actually has to be available at the actual time the message is sent in, and if one person doesn’t have the expertise to deal with it, the person that does have that expertise doesn’t have to be immediately available either. The reason the emergency calling is in place, is probably because it deters a lot of emergency service requests, and lowers the overall work load (and cost of labor) because obviously, calling has a much higher barrier to entry than just sending a message. Not only are they doing the pricing on their terms, following the numbers that “convert”, they are also doing their customer service on their terms as well, again, likely “following the numbers”. This is what a “numbers centric” user experience feels like, I guess. Every OTA Is The Same, Booking.Com Needs To Do It To Compete This is just . wrong In fact, one of the reasons I prefer to use Booking.com is because they include taxes and VAT in their prices during the search, unlike Agoda, Hostelbookers and other OTAs that I’ve tried in the past. An OTA that does the same thing that Booking does, but actually includes cleaning fees in the price all the way from search, to property page, to check out, is AirBNB. Cleaning Fee/By Number of nights included in search. Sadly, AirBNB doesn’t include the service fee in search, but Airbnb users will be familiar with that, and unlike with Booking.com, everything is actually included in every total you ever see. As you can see, nightly fee plus cleaning fee tallied up in the total. Every other OTA is following the numbers and bordering on fraud as long as it increases short term profits, is not an excuse to do the same. It is the exact reason why Booking or any OTA that wants to win in the long term should be consumer focused, protect their reputation, and be 100% clear with pricing from search, all the way to booking and check out. Be respectable and transparent and you will gain customer loyalty you can take to the bank. (Or if none of the OTAs are willing to do that, this leaves a gap in the market waiting to filled by one of the very hackers reading this post right now. Takeaways For any startups out there that want my business, or any other “idiot” end user’s business, month after month, year after year, for life, there are a few lessons here. Numbers =/= Truth The numbers don’t always show the whole picture of what your customers are actually experiencing and thinking. Exactly how they are interacting with your service. Routinely go through your own sales journey and check that everything makes sense, that you are not cutting corners anywhere. Actually communicate with your customers and listen to them in ways that are completely unscalable (don’t take my word for it, over at masters of scale.) listen to the co-founder of Linkedin, talk with the co-founder of AirBNB about this exact thing Transparency Is Key For Healthy Customer Relationships I am not the first customer that has been burned by this lack of transparency, and I not going to be the last. (Unless this post inspires some change, which I highly highly doubt.) Needless to say I am not thrilled with Booking.com, and I have begun using alternatives, and fishing around for something better. Actual Customers First It seems to me like Booking.com is caught up in their growth, trying to sell as many Hotels, and now apartment/condo/rental owners on their service as possible. To do that, obviously better numbers, more bookings through their service, the easier the sell. But that shouldn’t distract them from the end user. At the end of the day, since Booking.com is a commission based model, not a subscription based, they are not getting paid by the hotels, they are getting paid by people like me, (through taking a cut from the hotel I’m staying at). Hotels and apartment owners are invaluable business partners that Booking.com can’t exist without, but no business survives for long after it loses sight of it’s customers.

What Booking.Com Can Teach Startups NOT To Do With Their UX (And How I Spent 130$ Instead of $60)

Monit monitors Geth, autorestarts it on crashes and sends email alerts. Good, good Monit! I’m running geth and back-end on a low-cost Digital Ocean (DO) Ubuntu droplet. I use to autorestart geth and send email alerts when something goes wrong with the processes. TheMillionEtherHomepage.com monit Here I’ll cover a working solution and a beautiful one which isn’t working (hope somebody will eventually fix it). Install and setup monit $ sudo apt-get update $ sudo apt-get install monit Backup the config file and start editing it with nano: $ sudo cp /etc/monit/monitrc /etc/monit/monitrc-orig # backup $ sudo nano /etc/monit/monitrc Allow access to monit status. Uncomment these lines: set daemon 120 # number of seconds between checkups set httpd port 2812 and     use address localhost # only accept connection from localhost    allow localhost # allow localhost to connect to the server Let monit include *.cfg files from its conf.d directory. Uncomment (or add at the very end): include /etc/monit/conf.d/*.cfg Set up mail server to send alerts. Add these lines if you are using gmail: # GMAIL set mailserver smtp.gmail.com port 587     username "username@gmail.com" password "12345678"     using tlsv1     with timeout 30 seconds 

set alert username@gmail.com # monit will send alerts to this address Exit nano editor: Ctrl+X to save, type Y, press enter, and enter again when it asks for a filename (leave the same filename). Set up permossions as monitrc now has very sensitive data. $ sudo chmod 600 /etc/monit/monitrc For better understanding of monit: Video — Monitoring Linux Systems and Services with Monit Digital Ocean: How To Install and Configure Monit Setup geth monitoring — the working solution Create and start editing geth.cfg file with nano: $ sudo nano /etc/monit/monitrc/geth.cfg Paste this code: # GETH CHECK PROCESS geth MATCHING "[g]eth.*fast"     start program = "/bin/bash -c 'geth --fast --rpc --rpcport 8545 --rpccorsdomain localhost --cache=16 >/dev/null 2> /home/my-logs-folder/geth.log'" as uid username as gid username     stop program = "/bin/bash -c 'kill -HUP $(ps aux | grep '[g]eth' | awk '{print $2}')'" as uid username as gid username     if not exist then alert     if not exist then restart Ctrl+X to save, type Y, press enter, and hit enter again when it asks for a filename. We use >/dev/null here because geth outputs everything to the stderr (standard error output). And we save all stderr output (i.e. all logs) to the /home/my-logs-folder/geth.log file. We use -HUP signal because -SIGINT (which you typically send with Ctrl+C) will not reach geth here. Restart monit: $ sudo monit reload This config will perfectly send an email to you when geth crashes and will perfectly auto-restart geth But. The disadvantage here is that it cannot send “graceful” -SIGINT signal to geth through monit. And have to send -HUP instead, which is presumably not safe ( ). I tried it and it works, but I prefer to send -SIGINT manually instead: Is it safe to kill geth with SIGTERM? $ sudo monit unmonitor geth # so that monit won't restart geth again $ PID_OF_GETH=`pidof geth` # get geth's process ID $ kill -2 $PID_OF_GETH # KILL IT NOW!... but do it gracefully. This is clumsy. I’ve tried to make it more graceful but failed. Posted this question at stackexchange — How to monitor and auto-restart geth with monit? Setup geth monitoring — the right way I know that the config should look very similar to this. geth.cfg # GETH CHECK PROCESS geth with pidfile "/home/username/monit/geth.pid"     start program = "/bin/bash -c '/home/username/monit/geth.sh start'" as uid username as gid username     stop program = "/bin/bash -c '/home/username/monit/geth.sh stop'" as uid username as gid username     if not exist then alert     if not exist then restart geth.sh #!/bin/bash PID='/home/username/monit/geth.pid' LOGS='/home/username/monit/geth.log' KEYS='\--fast --rpc --rpcport 8545 --rpccorsdomain localhost --ipcpath /home/username/.ethereum/geth.ipc --cache=16' case $1 in     start)         setsid geth "$KEYS" &> "$LOGS" &         echo $! > "$PID"     ;;     stop)         kill -SIGINT `cat "$PID"`         rm "$PID"     ;;     *)     echo "usage: geth.sh {start|stop}"     ;; esac exit 0 Beautiful isn’t it? If you know how to make it work please submit your answer here — How to monitor and auto-restart geth with monit? Get monit status After you restart monit, you can start geth with the following command: $ sudo monit start geth This will run geth, autorestart it on crashes and notify you via email if something goes wrong. You can also check the monit status by the following command: $ sudo monit status And have a screen like this (mlneth here is python back-end of my ): project Monitoring geth Happy monitoting and no alerts to you all!

How to monitor geth and autorestart it on crashes with monit

Essential Entity Framework Core Tips: How to Optimize Performance, Streamline Queries, and More

How to Build an End-to-End Encrypted Chat with Seald and PubNub 

Cómo crear un chat cifrado de extremo a extremo con Seald y PubNub

Comment créer une conversation cryptée de bout en bout avec Seald et PubNub

सील्ड और पबनब के साथ एंड-टू-एंड एन्क्रिप्टेड चैट कैसे बनाएं

Seald と PubNub を使用してエンドツーエンドの暗号化チャットを構築する方法

Como construir um bate-papo criptografado de ponta a ponta com Seald e PubNub

Cách xây dựng cuộc trò chuyện được mã hóa đầu cuối với Seald và PubNub

如何使用 Seald 和 PubNub 构建端到端加密聊天

Nowadays, implementing full-text search is one of the most important parts of application development. In applications that rely heavily on search functionality, such as music services or online stores, the configuration and customization of answer ranking is vital. In order to better understand why you need to implement such a solution, let's consider the problems in its absence Enhancing Search Functionality Often developers are tasked with improving search in an application, and in many cases, quite a lot of time is spent putting together a clear set of refinements for the project. Common tasks to improve search might include the following: Speeding up search performance Add error tolerance Add the ability to search beyond the item name Add the ability to search by words not necessarily in the same order Add the ability to search other forms of words from a query Add the ability to manage search rules for the same word with different values Evaluation Criteria The main criteria for evaluating search performance can be defined as the speed of response, completeness and accuracy. While response rates can be easily measured and evaluated, the other two are a bit more difficult to calculate. Search completeness is the result of dividing the number of items returned by the number of matching items. When solving a problem of the first kind, with the exclusion of matching items, the problem of an incorrect query with an error or typo is often solved as well. The precision of the search is the result of dividing the number of matching items in the answer by the number of items in the answer. Those items that made it into the answer, but should not have, are called errors of the second kind. Accordingly, we need the fastest answer, with the highest percentages of completeness and search accuracy. The balance between these elements is unique to each project. Let's try to consider possible solutions to this problem without implementing full-text search. Attempting a solution via SQL LIKE The simplest solution may be the use of LIKE in SQL. If you try to implement this search on several fields, the query can look like this: SELECT p.id,
  p.title,
  p.image,
  u.name,
  p.created_at
FROM posts p
JOIN users u ON p.author_id = u.id
WHERE p.title LIKE '%query%'
  OR p.text LIKE '%query%'
  OR u.name LIKE '%query%'
  OR u.email LIKE '%query%'; However, this is far from the most optimal variant and if the records in the posts table are more than 1000, then even considering that the indexes are set, the queries will still be processed on the verge of timeouts. Furthermore, this type of query is appropriate solely for addressing a specific task, where all fields are utilized in the search. However, other tasks, notably rearranging the word order within the query, prioritizing elements, and enhancing the query's search speed, remain largely unresolved. Full-text search in PostgreSQL/MySQL The second solution with the existing set of tools in the application can be to use the full-text search features of PostgreSQL and MySQL. In this case, the query will be of the following form: SELECT ... MATCH (field) AGAINST ('word'). The decision to use SQL gives us 100% accuracy and completeness of search but also has a large number of disadvantages. Among them are the need for constant customization of the database and limitations on the type of fields and lack of ranking, as well as the final cost of such a solution. Laravel Scout To solve all of the above problems there are special services that quickly produce full-text search and solve problems with tokenization and morphological analysis. Laravel Scout allows you to work with many of these services and provides a unified interface for working with search, as well as linking entity search with Laravel models. Below is a list of popular tools that work with full-text search. Bolded are those tools that have a driver to work with Laravel Scout. Underlined are those that have such a driver out of the box. ElasticSearch Apache Solr Sphinx Algolia MultiSearch MeiliSearch The principle of working with full-text in Laravel does not differ much depending on the driver. I chose Algolia to demonstrate how it works. Laravel Scout makes it easy to add data to the Algolia index and just as easy to retrieve it from there by searching many fields. Of course, when choosing any vendor, your project will acquire a dependency that needs to be kept in mind. Laravel Scout will help make the dependency less, thanks to its interfaces. Customization Features To customize Algolia, we need to download the algolia/algoliasearch-client-php package. and set the id and secret from your application to Algolia. This is all we need for Algolia and our application to work and communicate properly. It's also worth noting that for the production solution, we need to add full queue support, as under the hood, when updating data in the selected service asynchronously, that can speed up the search performance a lot. Let's consider our further actions with full-text search on the example of Algolia. Working with full-text search on Algolia Service Algolia is partially free, but its minimum free package is probably not enough for any popular site. The important thing to emphasize is that if you choose other options that will run on your servers, such as the popular , the server, and support costs can easily overlap the cost of using Algolia. ElasticSearch After creating the application and adding credentials to the .env file and customizing the cache, we need to connect the Searchable trait to the models we need. After that the standard customization is complete, however, in some cases, we need to add a few customizations. Additional settings For example, in the model, we can specify which fields we will stack in Algolia using the method toSearchableArray() public function toSearchableArray(): array
{
   return [
       'id' => $this->id,
       'title' => $this->title,
       'author_id' => $this->author_id
   ];
} Also, if the primary key of our model is not id, we can change it and add its name, for example, this way: public function getScoutKey(): string
{
   return $this->title;
}


public function getScoutKeyName(): string
{
   return 'title';
} Laravel Scout also has the option to set the search engine to search separately for each model using the method. searchableUsing() Indexing records Most often, full-text search is implemented in a project after a large number of records have appeared in the project. In order to index these records in Algolia we need to use the command . php artisan scout:import "App\Models\Post" You can also add special conditions or related models when indexing using the method if needed. After indexing, you can see the indexed records in Algolia in an index formed by the same principles as the table name in migrations i.e for Post, there will be posts. makeAllSearchableUsing() If you see the records here, the indexing was successful. Further adding and updating of indexed records will happen automatically as Laravel Scout listens to events in the model. It is also possible to add and modify indexes via a method to the Builder or to the Collection that contains the Model objects Post::where('id', '>', 100)->searchable(); Or $user->posts()->searchable();
//OR
$posts = Post::where('id', '>', 100)->get();
$posts->searchable(); For the last case, we can specify additional links using a separate method makeSearchableUsing() If we need to limit the records that should be included in the index when using or , we can apply the method save() update() shouldBeSearchable() public function shouldBeSearchable(): bool
{
   return $this->status === 'published';
} Deletion To remove records from the index, simply use the method for the same Model, Builder, Models Collection, and relation entities. Also in Laravel Scout, you have the option to enable SoftDelete, so that deletion from the database is not so critical. unsearchable() Search Finally, we get to the most important thing - checking that our full-text search works. In order to test this, we can use the method. search() Post::search('repudiandae')->get(); Also, our model can be in several indexes at the same time for different checks. In this case, we specify the index in the method. within() Additionally, Scout search has the ability to use pagination through the method, as well as to use simple checks in . Thus a query can look like this: paginate() where() Post::search('repudiandae')
   ->within('another_index_with_posts')
   ->where('author_id',  $authorId)
   ->paginate(15); Customizing search The search method searches all fields by default. To change this, you need to specify the list of fields in the index that should be checked. already has error tolerance by default, but this can also be changed in the Typo-tolerance tab. As you may have noticed in the previous screenshot, there are a large number of full-text search settings. Algolia Often, to properly handle customization, Algolia requires a clear set of rules that determine which element to reflect above. You can also configure stop words or set up context for certain words and queries. Once full-text is implemented, there is supposed to be a lot of ongoing work to tune it to continually increase the completeness and accuracy of the search. To understand why the tool selected a particular element and why one is higher and the other lower, you can use the method instead of . raw() get() Conclusion As we have seen today, implementing is an important task for a large number of projects, but the initial setup may not take much time. Implementing search right away will give a big boost in search performance and search efficiency. The important issues in this matter are the choice of tool and the subsequent customization iterations. full-text search

How to Implement Full-text Search in a Laravel Project

5 Essential Python Packages You Should Know

GraphQL is an API query language that allows clients to get the data they need more efficiently and flexibly than traditional REST APIs. In recent years, GraphQL has gained a lot of popularity and has become one of the most popular technologies for API creation. At the same time, Next.js is a highly efficient and scalable web application development framework that has become very popular with web developers. This tutorial will explore how to create a GraphQL server and client with Next.js to provide a more efficient and flexible development experience for our users. this tutorial assumes you have basic knowledge of GraphQL and Nextjs (pages directory). Before starting: We will use to make requests and retrieve fake JSON data, in particular, we will use dummyJSON https://dummyjson.com/docs/users Setting Up We create a new Next.js project with the following command and follow the steps indicated. This time we will use , you can use the package manager of your choice. pnpm pnpm create-next-app We install the dependencies that we will need in the project: pnpm install @apollo/server graphql @as-integrations/next apollo-server-core @apollo/client graphql-tag @nextui-org/react is the main library for Apollo Server itself. @apollo/server: An Apollo Server integration for use with Next.js. @as-integrations/next: to create and consume API’s in Graphql language. graphql: to create and manage GraphQL servers simply and flexibly. apollo-server-core: to handle GraphQL requests and statuses on clients. @apollo/client: to build and manipulate GraphQL queries in JavaScript. graphql-tag: library of user interface components. I will use this library only to quickly style the application, feel free to use the one you want. @nextui-org/react After that, we will create the following structure for the project: ...
├── src/
│   ├── graphql/
│   │   ├── queries/
│   │   │   ├── getUseres.gql
│   │   │   └── searchUser.gql
│   │   ├── apollo-client.js
│   │   ├── resolvers.js
│   │   └── schemas.js
│   ├── pages/
│   │   ├── api/
│   │   │   └── graphql.js
│   │   ├── _app.js
│   │   ├── _document.js
│   │   └── index.js
│   │   ...
│   ├── utils/
│   │   └── cors.js
├── .env.local
... Now we will create the file and create the environment variables that we are going to use: .env.local /* we add the prefix NEXT_PUBLIC_ to the variable that will havethe graphql server url defined, this way we will be able toaccess to it client side */

NEXT_PUBLIC_URL_SERVER_GRAPHQL=http://localhost:3000/api/graphqlURL_API=https://dummyjson.com/users Graphql server We will create the GraphQL server inside the directory since it’s where the server created by Nextjs lives. 1— /api : graphql.js import { ApolloServer } from "@apollo/server"
import { startServerAndCreateNextHandler } from '@as-integrations/next'
import { ApolloServerPluginLandingPageGraphQLPlayground } from "apollo-server-core"

import typeDefs from "@/graphql/schemas"
import resolvers from "@/graphql/resolvers"
import allowCors from "@/utils/cors"

const apolloServer = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [ApolloServerPluginLandingPageGraphQLPlayground()]
})

const handler = startServerAndCreateNextHandler(apolloServer, {
  context: async (req, res) => ({ req, res }),
})

export default allowCors(handler) The GraphQL server has two main parts: schemas (typeDefs) and resolvers. The schemas define the structure of the data and the queries that can be made to the server, while the resolvers define how the data is obtained and processed. We also add to the initial configuration of the server the definition of . This plugin provides a GraphQL playground page that allows us to test queries in a more user-friendly way. ApolloServerPluginLandingPageGraphQLPlayground Finally, is used to enable Cross-Origin Resource Sharing (CORS) support on the server. This function adds the necessary CORS headers to the response. allowCors : utils/cors.js const allowCors = (fn) => async (req, res) => {
  res.setHeader('Access-Control-Allow-Credentials', true)
  res.setHeader('origin', 'https://nextjs-graphql-server-client.vercel.app')
  res.setHeader('Access-Control-Allow-Origin', req.headers.origin || '*')
  // another common pattern
  res.setHeader('Access-Control-Allow-Methods', 'GET,OPTIONS,PATCH,DELETE,POST,PUT')
  res.setHeader(
    'Access-Control-Allow-Headers',
    'X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version',
  )
  if (req.method === 'OPTIONS') {
    res.status(200).end()
    return
  }
  await fn(req, res)
}

export default allowCors In this file, we have defined the basic headers that the app needs to be able to make requests to the Graphql server. This middleware is fully customizable to the requirements of your application, you can remove or add more headers, either known headers or custom headers that only your app uses. You need to add the necessary headers so you can make requests to the server either using this middleware or directly in your requests. Schema creation 2— : schemas.js import { gql } from 'graphql-tag'

const typeDefs = gql`
  type Query {
    users: [User]
    searchUser(value:String):[User]
  }

  type User {
    id: ID
    firstName: String
    lastName: String
    email: String
    username: String
    image: String
  }
`
export default typeDefs We define a GraphQL schema using . The function is used to convert a string into a valid GraphQL schema document. gql gql In the Schema, we define a query type called , which has a property called , which is a list of objects of type . Query users User We also have the query called which receives a string value with which we will filter the users that match the value. For this tutorial, we will create the type with only some of the API returned properties. searchUser User Resolvers creation 3— : resolvers.js const resolvers = {
  Query: {
    users: async () => {
      try {
        const response = await fetch(process.env.URL_API)
        const data = await response.json()

        return data.users.map(u => {
          return {
            id: u.id,
            firstName: u.firstName,
            lastName: u.lastName,
            email: u.email,
            username: u.username,
            image: u.image
          }
        })
      } catch (error) {
        throw new Error("Something went wrong")
      }
    },
    searchUser: async (_, { value }) => {
      try {
        const response = await fetch(`${process.env.URL_API}/search?q=${value}`)
        const data = await response.json()

        return data.users.map(u => {
          return {
            id: u.id,
            firstName: u.firstName,
            lastName: u.lastName,
            email: u.email,
            username: u.username,
            image: u.image
          }
        })
      } catch (error) {
        throw new Error("Something went wrong")
      }
    }
  }
}

export default resolvers We define the resolvers that correspond to each query. The resolvers request the external API, which returns a JSON with a list of users. We do a mapping of the data received from the API to return only the data that we will use in the application. In case something goes wrong during the request or the data processing, an exception is thrown with the message “Something went wrong”. Now let’s run the application, go to the path and execute the queries created: /api/graphql GraphQL client Creation of an instance of an Apollo client. 1— import { ApolloClient, InMemoryCache } from "@apollo/client" import { ApolloClient, InMemoryCache } from "@apollo/client"

const client = new ApolloClient({
  uri: process.env.NEXT_PUBLIC_URL_SERVER_GRAPHQL,
  cache: new InMemoryCache(),
})

export default client The client is created with two main properties: and . The uri property is the GraphQL API address to which the client will connect. In this case, we will use the environment variable created earlier that stores the API address. uri cache NETX_PUBLIC_URI_SERVER_GRAPHQL The property is used to store the data that is downloaded from the API in cache. This way, the client can access the data without making a new API query. cache This component provides functionality, which allows an instance of an Apollo client to access all components rendered within it. 2— ApolloPrivider import { ApolloProvider } from '@apollo/client'

import client from "@/graphql/apollo-client"

export default function App({ Component, pageProps }) {
  return (
    <ApolloProvider client={client}>
        <Component {...pageProps} />
    </ApolloProvider>
  )
} Creation of queries in files. 3— .gql : getUser.gql query getUsers {
 users {
  id
  firstName
  lastName
  email
  username
  image
 }
} : searchUser.gql query getSearchUsers($value: String) {
 searchUser(value: $value) {
  id
  firstName
  lastName
  email
  username
  image
 }
} : next.config.js const nextConfig = {
 ...
  webpack: (config, options) => {
    config.module.rules.push({
      test: /\.(graphql|gql)/,
      exclude: /node_modules/,
      loader: "graphql-tag/loader"
    })

    return config
  }
  ...
} In order to use or files in Next.js, it’s necessary to add a webpack configuration in the Nextjs configuration. .graphql .gql Here you can read more about it. Making server-side and client-side requests. 4— : index.js import { useEffect, useRef, useState } from 'react'
import { useLazyQuery, useQuery } from '@apollo/client'

import Head from 'next/head'
import { Button, Container, Grid, Input, Spacer, User, Row, Loading } from "@nextui-org/react"

import GET_USERS from '@/graphql/queries/getUsers.gql'
import SEARCH_USERS from '@/graphql/queries/searchUsers.gql'

export default function Home() {
  const [users, setUsers] = useState([])
  const [searchValue, setSearchValue] = useState('')

  const usersRef = useRef(null)

  const { data, loading, error } = useQuery(GET_USERS)

  const [getSearchedUsers] = useLazyQuery(SEARCH_USERS, {
    fetchPolicy: 'network-only',
    onCompleted(data) {
      setUsers(data.searchUser)
    }
  })

  useEffect(() => {
    if (data) {
      setUsers(data.users)
      usersRef.current = data.users
    }
  }, [data])


  const searchUser = () => {
    getSearchedUsers({
      variables: {
        value: searchValue
      }
    })
  }

  if (error) {
    console.error(error)
    return null
  }

  return (
    <>
      <Head>
        <title>Nextjs and Graphql Setup</title>
        <meta name="description" content="Generated by create next app" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <main >

        <Container css={{ display: 'flex', justifyContent: 'center' }}>
          <Spacer y={2.5} />
          <Row justify="center" align="center">

            <Input
              clearable
              labelPlaceholder="User"
              onClearClick={() => setUsers(usersRef.current)}
              initialValue={searchValue}
              onChange={(e) => setSearchValue(e.target.value)}
            />
            <Button color="gradient" auto onClick={() => searchUser()}>
              Search user
            </Button>
          </Row>

          <Spacer y={2.5} />
          <Row justify="center" align="center">

            {loading
              ?
              <Loading />
              :
              <Grid.Container gap={2} justify="center">
                {users.map(u => (
                  <Grid xs={3}
                    key={u.id}
                  >
                    <User
                      src={u.image}
                      name={`${u.firstName}${u.lastName}`}
                      description={u.email}
                      size="lg"
                      bordered
                      color="gradient"
                    />
                  </Grid>

                ))
                }
              </Grid.Container>
            }

          </Row>
        </Container>
      </main>
    </>
  )
} In the above code, we will use the hook to get the users with the query and then save it in the state. useQuery GET_USERS We also use Apollo’s hook to perform a search on the users when the user clicks on the “Search user” button. When the query is finished we save the results in the state. useLazyQuery That’s it! now we can use graphql server-side and client-side. You can add as many queries and resolvers as you need. The app looks as follows: See the demo here Repo here Conclusion In summary, using GraphQL in a Next.js project can significantly improve the application’s efficiency, flexibility, documentation, security, and scalability. Hopefully, this will serve as a guideline for your future projects. Want to connect with the author? Love connecting with friends all around the world on . Twitter Read more: How to Create a Modern Skeleton Loader in React to Improve User Experience How to Simulate a Backend REST API with json-server for CRUD Development in React Also published . here

Setting up a GraphQL Server and Client in Next.js

Everybody says “attribution is the holy grail of marketing” but how many growth teams actually go the extra mile to build a robust and accurate attribution model? With an explosion of channels and devices, prospects are interacting with brands from varied sources, and customer acquisition channels do not talk to each other (unless you make them do so). Therefore, teams have two options – rely on their guts and assumptions of customer journeys or collect and model the touchpoints that a customer has with their brand. Either way, as GTM becomes more and more revenue-centric, the answer to what channels are working should be precisely defined, and should reflect the truth. GTM What is attribution and why is it important? For the uninitiated (founders and non-marketing folks) – attribution in refers to the process of identifying and assigning credit to the marketing channels or touchpoints that contributed to a desired customer action, such as making a purchase or completing a lead form. The goal of attribution is to understand which marketing efforts are most effective in driving conversions and to optimise marketing spend accordingly. marketing There are several different attribution models that marketers can use, including . First-touch attribution gives credit to the first touchpoint a customer has with a brand, while last-touch attribution gives credit to the final touchpoint before a conversion. Multi-touch attribution assigns credit to all touchpoints along the customer journey. first-touch attribution, last-touch attribution, and multi-touch attribution Effective attribution requires the use of data analytics and marketing automation tools to track customer interactions across channels and measure the impact of each touchpoint on the customer journey. The role CDPs can play in attribution modelling – A customer data platform (CDP) is a centralized system that collects, integrates, and manages customer data from various sources to create a unified customer profile. CDPs can integrate with various data sources, including website, apps, customer relationship management (CRM) systems, marketing automation platforms, and other third-party data sources. Additionally, they offer a marketer-friendly interface, allowing marketers to easily access and utilize customer data without relying on IT or technical resources. Given that CDPs are continuously extracting, transferring and loading customer data to customer data warehouses, the destination warehouse becomes the source of truth of customer journeys. The more channels CDP integrates, the better the view of customer journey that we will discover. Hence, CDPs are central to attribution modelling. All modelling logics can be built in CDPs and can be visualized with a business intelligence tool of choice. What is RudderStack and how does it work? is one of the up and coming CDPs, built with a warehouse first architecture. Its freemium offering is allowing organisations to set it up quickly, and experience the utility of CDPs without any purchase. RudderStack CDPs, including RudderStack, have 3 major elements – – these are ways to extract/capture data from different platforms (third party cloud apps, your web and app properties, server integrations etc.). Sources – these are data storage management systems or cloud apps that receive data from sources. Destinations – these are methods to transform and clean data before sending data to the destination. Transformations Newer CDPs like RudderStack also have a feature called Reverse ETL that extracts data from destinations and sends it to other cloud applications/destinations. This is usually done to activate and utilize the collected data. How do you use RudderStack for first touch attribution modelling? One of the most interesting use-case of RudderStack that I have discovered is to use its Javascript SDK as a source of collecting page views and other interactions on the website properties, and building a customer journey out of it. Here’s a step-by-step guide to visualizing the customer journey and identifying the first touch of any lead – – Sign up for RudderStack here. Step 1 Visit ‘Sources’ inside the RudderStack console, and click on ‘New Source’. Step 2 – – Select ‘Javascript’ from the grid of all the sources. Step 3 – Name the source as ‘website_prod_test’ and then, copy the snippet that’s generated. Step 4 – Install the javascript on your website using google tag manager or your native CMS custom script addition capability. Step 5 – Visit your website and you’ll start to see events in the event flow within the source. Everytime a new website visitor arrives, RudderStack will provide an anonymous ID to it, and start tracking all page views on the website. The anonymous ID is stored in the cookieStore of the visitor’s browser, and even if the visitor visits the website across different sessions, it will still track page views against the same visitor. Step 6 – Setup the Google BigQuery destination following the official instructions provided by RudderStack . Step 7 here – Go to the sources tab, select your Javascript source, go to overview and connect your BigQuery destination. Once the destination is connected, the event stream from your JS source will start to flow into your Google BigQuery data warehouse destination. Step 8 – Next, you need to identify your website visitors when they have filled a form on your website using Let’s say, if a visitor fills a form on your website, they land on a thank you page, and the email address of the visitor is added to the localStorage as an item. You need to execute the following code to identify a visitor and map the email address against the anonymous ID. Step 9 rudderanalytics.identify(
    rudderanalytics.getAnonymousId(), {
        email: localStorage.getItem(“email”),
    }
    },
    () => {
        console.log("identify call");
    }
); – Finally, when you have made the identify call as shown in the last step, the identity event will get passed to the Google BigQuery data warehouse, and you need to execute a SQL query as following, and you’ll get the first page visited by each identified visitor (i.e. leads who filled the form): Step 10 WITH
  added_row_number AS (
  SELECT
    p.anonymous_id AS `anonymous_id`,
    p.context_page_url AS `context_page_url`,
    p.referrer AS `referrer`,
    p.original_timestamp AS `timestamp`,
    ROW_NUMBER() OVER(PARTITION BY p.anonymous_id ORDER BY p.original_timestamp ASC) AS row_number
  FROM
    `website_prod_test.pages_view` p),
  journey AS (
  SELECT
    u.email,
    added_row_number.`anonymous_id` AS `id`,
    added_row_number.`context_page_url` AS `first_page_seen`,
    added_row_number.`referrer`,
    added_row_number.`timestamp`,
    added_row_number.row_number,
    CASE 
    WHEN CONTAINS_SUBSTR(added_row_number.`context_page_url`, "utm_medium=cpc") THEN added_row_number.`context_page_url`
    WHEN CONTAINS_SUBSTR(added_row_number.`referrer`, "utm_medium=cpc") THEN added_row_number.`referrer`
    WHEN CONTAINS_SUBSTR(added_row_number.`context_page_url`, "utm_medium=email") THEN added_row_number.`context_page_url`
    WHEN CONTAINS_SUBSTR(added_row_number.`referrer`, "utm_medium=email") THEN added_row_number.`referrer`
    ELSE added_row_number.`context_page_url`
    END
    AS `attribution_url`,
  FROM
    `wesbite_prod_test.users_view` u
  LEFT JOIN
    added_row_number
  ON
    u.id = added_row_number.anonymous_id)
SELECT
  *,
  REGEXP_EXTRACT(attribution_url, r".*[&?]utm_source=([^&]+).*") AS `utm_source`,
  REGEXP_EXTRACT(attribution_url, r".*[&?]utm_medium=([^&]+).*") AS `utm_medium`,
  REGEXP_EXTRACT(attribution_url, r".*[&?]utm_campaign=([^&]+).*") AS `utm_campaign`,
  REGEXP_EXTRACT(attribution_url, r".*[&?]utm_content=([^&]+).*") AS `utm_content`,
  REPLACE(REGEXP_EXTRACT(attribution_url, r".*[&?]utm_term=([^&]+).*"), "%20", " ") AS `utm_term`
FROM
  journey
WHERE
  journey.row_number = 1
  ORDER BY journey.timestamp DESC – Once you run this query, Google interface will give you an option to visualize the result using Looker studio. You can follow our guide to or refer to Looker studio documentation to quickly generate a dashboard as shown below. It will show you the journey taken by an individual along with the timestamp and the referrer. Step 11 BigQuery Looker Studio for marketers This was a quick, super-specific method of building a low cost first touch attribution model using RudderStack. There’s so much more to RudderStack, CDPs and attribution modelling. If you’re interested in implementing a CDP for your SaaS product, reach out to me. This article was originally posted . here

Stories, News & Mentions about UPMAIL

Upmail’s Stories on HackerNoon

Upmail's News & Mentions