@supports (display: grid) {
  .grid {
    /* grid layout code here */
  }
}

@media (prefers-reduced-data: reduce) {
  .image {
    background-image: url("images/placeholder.jpg");
  }
}

Are you an artist and wondering how to kick-start selling your artwork online? If yes, this post is for you.

In fact, artists and designers like you always look for various ways to sell their artworks and earn their livelihood. And nothing can be better than the online avenue that lets you showcase your art to the global customers.

As a designer, you must be looking for ways to establish your own graphic design business. But it is a time-consuming process, and you can’t achieve overnight. Until then, you can make good passive income by selling your artworks/designs online.

But which online platform is the best?

There are plenty of marketplaces out there that allow artists to open an account with them, enlist their products, and start selling. This overwhelming number may sometimes confuse you which platform to go with. That’s why we’ve shortlisted a few marketplaces based on comprehensive research.

Top 10 best places to sell your artwork online

1. PrintShop By Designhill

PrintShop by Designhill is the world’s #1 creative marketplace that brings artists/ graphic designers and design seekers together. While artists can use this marketplace for selling their designs on over 50 unique products, business owners and individuals can explore a plethora of designs created by designers across the world. You get an opportunity to showcase your artworks to millions of visitors.

Just open an account with the platform and start selling your designs.

2. Etsy

Etsy is just like a craft fair. This is yet another globally recognized online platform where you can sell almost all sorts of designs. But the website is more focused on selling handmade products and vintage items. Since the platform has millions of registered shoppers, the probability of getting you reasonable prices for your designs will always be high.

You can list your artworks @$0.20 per piece for four months. With millions of shoppers, the platform also has a massive number of artists creating fierce competition. This means only high-quality designs get noticed and sold. So, if you’re sure that your design is outstanding, then only list.

3. Redbubble

Redbubble is another reputed print-on-demand platform for independent artists. It allows you to set your profit margin, which means you decide your earning on your own. The platform is also home to many artist groups that serve as a source of inspiration to designers. You can register yourself for selling your artworks and making passive money online.

The platform is free to sign up. It lets you fully control what products you sell your design on and set price over the base price for each product.

4. Creative Market

Creative Market offers a robust marketplace on which to put your designs. Being a graphic designer, you may be creating fonts, templates, themes, or clip art. This platform allows you to showcase them all to millions of visitors from different corners of the world.

The main advantage of selling your artworks here is that you won’t be bound by any lock-in period. You’re free to set prices for your design on your own. You can make up to 70% of the sales price.

Also, the site doesn’t ask you for any exclusivity, which means you’re free to sell your designs elsewhere as well.

5. DeviantArt

Having over 47 million users, DeviantArt claims itself the most extensive online art gallery and community. The company is around two decades old, which has gained a good rapport by hosting a wide range of designs from global graphic designers. The platform allows artists to host their artworks in their own personal gallery for free.

The website also helps designers monetize their designs through DeviantArt Prints if DeviantArt approves your art. You can offer your designs on a variety of products such as canvas, fridge magnets, calendars, postcards, etc.

You can’t set the price on these items as a free user, and you can expect to earn around 16% of the product selling price. But if you become a core member by paying $15 quarterly or $50 annually, you can be able to set prices on your own; which means you can maximize your commission.

6. Threadless

Threadless is a free site. You can open an online store for free to sell your art to millions of potential customers from across the world. You can find a community of like-minded artists there. You can also put your designs for public review, and if your art gets a favorable vote by the majority of the community, the platform will help you promote your work.

7. Zazzle

Zazzle is also a great online marketplace where you can sell your designs to a wide range of audiences.

The platform allows you to open an online store for free and access to its top-notch tools to sell all sorts of designs on products such as business cards, stamps, tote bags, t-shirts, and many more.

8. Society6

Society6 has become one of the most prominent marketplaces for artists today and has nurtured thousands of global artists to date.

The platform allows you to open an account for free. Uploading your artworks in the correct resolution is incredibly seamless on this site. It offers framed prints, fine art prints, and stretched canvases in traditional art formats.

Society6 also provides plenty of resources to help you with pricing and marketing competitively. You get complete freedom to set your margin on per sale. The site releases payments on the first of every month.

9. Shopify

Shopify is an e-commerce platform that you can integrate with your own website. If you own a website but unable to sell products through it, integrate your site for boosting sales. The platform boasts over half-a-million participating stores representing nearly $82 billion in sales over the last 14 years.

The site charges for using its platform—pricing starts at $29/month. However, the platform allows you to use its 14-day free trial before you finally become a regular member. Your membership price covers your own store, free SSL certificate, unlimited products, sales channels, and many more.

And if your business grows, you can upgrade your plan to either $79/month or $299/month for larger-scale operations.

10. Fiverr

What initially launched for the freelancers to sell their services, Fiverr has now also turned as a popular platform for selling graphic design ideas, skills, and expertise. The site allows you to directly engage with your prospective buyers of design services and ideas to get your artwork’s desired prices.

Final thought

Online stores are the perfect places for selling artworks. The precise list of these online platforms will help you sell your artworks online. Since each site offers different profit margins, you must analyze them all and open stores with one that provides the optimum margins and best services.

Are you an artist and wondering how to kick-start selling your artwork online? If yes, this post is for you.

In fact, artists and designers like you always look for various ways to sell their artworks and earn their livelihood. And nothing can be better than the online avenue that lets you showcase your art to the global customers.

As a designer, you must be looking for ways to establish your own graphic design business. But it is a time-consuming process, and you can’t achieve overnight. Until then, you can make good passive income by selling your artworks/designs online.

But which online platform is the best?

There are plenty of marketplaces out there that allow artists to open an account with them, enlist their products, and start selling. This overwhelming number may sometimes confuse you which platform to go with. That’s why we’ve shortlisted a few marketplaces based on comprehensive research.

Top 10 best places to sell your artwork online

1. PrintShop By Designhill

PrintShop by Designhill is the world’s #1 creative marketplace that brings artists/ graphic designers and design seekers together. While artists can use this marketplace for selling their designs on over 50 unique products, business owners and individuals can explore a plethora of designs created by designers across the world. You get an opportunity to showcase your artworks to millions of visitors.

Just open an account with the platform and start selling your designs.

2. Etsy

Etsy is just like a craft fair. This is yet another globally recognized online platform where you can sell almost all sorts of designs. But the website is more focused on selling handmade products and vintage items. Since the platform has millions of registered shoppers, the probability of getting you reasonable prices for your designs will always be high.

You can list your artworks @$0.20 per piece for four months. With millions of shoppers, the platform also has a massive number of artists creating fierce competition. This means only high-quality designs get noticed and sold. So, if you’re sure that your design is outstanding, then only list.

3. Redbubble

Redbubble is another reputed print-on-demand platform for independent artists. It allows you to set your profit margin, which means you decide your earning on your own. The platform is also home to many artist groups that serve as a source of inspiration to designers. You can register yourself for selling your artworks and making passive money online.

The platform is free to sign up. It lets you fully control what products you sell your design on and set price over the base price for each product.

4. Creative Market

Creative Market offers a robust marketplace on which to put your designs. Being a graphic designer, you may be creating fonts, templates, themes, or clip art. This platform allows you to showcase them all to millions of visitors from different corners of the world.

The main advantage of selling your artworks here is that you won’t be bound by any lock-in period. You’re free to set prices for your design on your own. You can make up to 70% of the sales price.

Also, the site doesn’t ask you for any exclusivity, which means you’re free to sell your designs elsewhere as well.

5. DeviantArt

Having over 47 million users, DeviantArt claims itself the most extensive online art gallery and community. The company is around two decades old, which has gained a good rapport by hosting a wide range of designs from global graphic designers. The platform allows artists to host their artworks in their own personal gallery for free.

The website also helps designers monetize their designs through DeviantArt Prints if DeviantArt approves your art. You can offer your designs on a variety of products such as canvas, fridge magnets, calendars, postcards, etc.

You can’t set the price on these items as a free user, and you can expect to earn around 16% of the product selling price. But if you become a core member by paying $15 quarterly or $50 annually, you can be able to set prices on your own; which means you can maximize your commission.

6. Threadless

Threadless is a free site. You can open an online store for free to sell your art to millions of potential customers from across the world. You can find a community of like-minded artists there. You can also put your designs for public review, and if your art gets a favorable vote by the majority of the community, the platform will help you promote your work.

7. Zazzle

Zazzle is also a great online marketplace where you can sell your designs to a wide range of audiences.

The platform allows you to open an online store for free and access to its top-notch tools to sell all sorts of designs on products such as business cards, stamps, tote bags, t-shirts, and many more.

8. Society6

Society6 has become one of the most prominent marketplaces for artists today and has nurtured thousands of global artists to date.

The platform allows you to open an account for free. Uploading your artworks in the correct resolution is incredibly seamless on this site. It offers framed prints, fine art prints, and stretched canvases in traditional art formats.

Society6 also provides plenty of resources to help you with pricing and marketing competitively. You get complete freedom to set your margin on per sale. The site releases payments on the first of every month.

9. Shopify

Shopify is an e-commerce platform that you can integrate with your own website. If you own a website but unable to sell products through it, integrate your site for boosting sales. The platform boasts over half-a-million participating stores representing nearly $82 billion in sales over the last 14 years.

The site charges for using its platform—pricing starts at $29/month. However, the platform allows you to use its 14-day free trial before you finally become a regular member. Your membership price covers your own store, free SSL certificate, unlimited products, sales channels, and many more.

And if your business grows, you can upgrade your plan to either $79/month or $299/month for larger-scale operations.

10. Fiverr

What initially launched for the freelancers to sell their services, Fiverr has now also turned as a popular platform for selling graphic design ideas, skills, and expertise. The site allows you to directly engage with your prospective buyers of design services and ideas to get your artwork’s desired prices.

Final thought

Online stores are the perfect places for selling artworks. The precise list of these online platforms will help you sell your artworks online. Since each site offers different profit margins, you must analyze them all and open stores with one that provides the optimum margins and best services.

Although messengers can be considered as newcomers to the business scene, they already offer new opportunities for brands. They have a broad user base and regularly roll out new features and even apps that support doing business — such as Whatsapp for business. It’s no surprise that these newly available tools and platforms have been triggering new business approaches and one of them is Messenger-Based Sales.

Let’s define Messenger-Based Sales: a concept or an approach that prioritizes messengers as the primary communication channel between a buyer and a business throughout the sales process. Simply put, Messenger-Based Sales aims to produce a convenient and seamless buying journey via chat apps — communication platforms that customers use most.

It’s no surprise that it’s much easier to open up an app that is already installed on your phone if you want to send a message than write an email or make a phone call. We’re also getting more and more casual, favoring short bursts of messages over formal emails or sometimes even face-to-face conversations.

Let’s dive into the benefits of Messenger-Based Sales deeper and understand what makes it convenient for customers and businesses.

Why Messenger-Based Sales?

Asynchronous communication

One of the reasons why messaging apps are convenient is because of asynchronous communication. Unlike traditional communication methods, such as phone calls, emails, or even live chat, messengers allow us to respond in our own time, removing the pressure and the expectation of having to answer immediately.

Emoji, stickers & GIFs

Messengers can also be more interactive than other platforms. For example, adding an emoji to a chat can convey emotion and an animated GIF can make the conversation more entertaining.

No wonder why Facebook Messenger has even introduced larger-sized emoji — people love visual messages so much that every day on, they send over 900 million emoji-only messages on Facebook Messenger alone.

Automated responses

To save time and keep your audience engaged, messaging apps offer automated responses, also known as auto or instant replies. This means that if someone wants to start chatting with a messenger company, then the company can customize automatic answers to provide or gather information. This may include the company’s location or contact information.

Chat history

Another advantage of communicating with your potential and existing customers via messengers is because chat history is always available. It’s easy to miss something when you’re taking on the phone — you may lose the detail of the conversation. Live chats don’t always save your conversation history. By using messengers, on the other hand, you can know who you’re talking to, have access and review conversations with your clients, as well as access files and documents that you’ve shared.

Suitable for B2C & B2B buyers

Not only messaging apps can increase sales for B2C companies by offering advice, answering efficiently and offering options to submit inquiries, they’re also proving to be useful for B2B business.

Think about it, if people like chatting with each other, wouldn’t they like to connect with a B2B company just as quickly, especially in a lengthy purchase process such as B2B?

Moreover, B2B buyers demand that their buying journey is intuitive, secure and accessible. Research shows that 70% of customers say that convenience is essential.

High open rate & engagement

Although email is doing better at open rate and engagement when compared to a phone call, according to statistics, the open rate of mailing lists is still low, with just 2.4% of the audience who follow the links inside the emails. In addition, many emails end up in spam folders that would never get read.

It’s no surprise that today, people are far more likely to view and click a message in the messaging app. Firstly, the texts are usually short and thus much faster to read. Secondly, we always get notified about them right on our screen. Last but not least, conversations via chat apps just tend to be lighter and less formal.

Convenient for marketing, sales & customer support

Nowadays, customers expect immediate responses — they want companies to reach back to them as quickly as they can. And although messengers haven’t been utilized in the majority of businesses across the globe, they have already started to gain traction in various departments, including marketing, sales, and customer support.

Marketing team

Whether it’s sending out polls, delivering the latest blog posts or running ads, messengers have been used as marketing automation tools. Many companies already employ messaging apps for marketing purposes.

Sales team

With messengers, the sales team can carry the conversation throughout their entire pipeline. Payment can be made directly from the chat.

Support team

With messaging apps, the support team can do a much better job. Messengers are much quicker than emails; they have fewer formalities, offer asynchronous communication and multimedia exchange. Additionally, by creating a chatbot for frequently asked questions and replying to many users simultaneously 24/7, sales and support teams can save their time and focus on the more important stuff.

It’s always notable when the world biggest CSS framework goes up a major version (it’s in alpha now).

It has dropped jQuery and IE, started using some CSS custom properties, gone fully customized with form elements, started to embrace utility classes, and includes a massive icon set you can use via SVG sprite. Sweet.

Direct Link to Article — Permalink

The post Bootstrap 5 appeared first on CSS-Tricks.

I’ve always wanted to build an API, but was scared away by just how complicated things looked. I’d read a lot of tutorials that start with “first, install this library and this library and this library” without explaining why that was important. I’m kind of a Luddite when it comes to these things.

Well, I recently rolled up my sleeves and got my hands dirty. I wanted to build and deploy a simple read-only API, and goshdarnit, I wasn’t going to let some scary dependency lists and fancy cutting-edge services stop me¹.

What I discovered is that underneath many of the tutorials and projects out there is a small, easy-to-understand set of tools and techniques. In less than an hour and with only 30 lines of code, I believe anyone can write and deploy their very own read-only API. You don’t have to be a senior full-stack engineer — a basic grasp of JavaScript and some experience with npm is all you need.

At the end of this article you’ll be able to deploy your very own API without the headache of managing a server. I’ll list out each dependency and explain why we’re incorporating it. I’ll also give you an intro to some of the newer concepts involved, and provide links to resources to go deeper.

Let’s get started!

A rundown of the API concepts

There are a couple of common ways to work with APIs. But let’s begin by (super briefly) explaining what an API is all about: reading and updating data.

Over the past 20 years, some standard ways to build APIs have emerged. REST (short for REpresentational State Transfer) is one of the most common. To use a REST API, you make a call to a server through a URL — say api.example.com/rest/books — and expect to get a list of books back in a format like JSON or XML. To get a single book, we’d go back to the server at a URL — like api.example.com/rest/books/123 — and expect the data for book #123. Adding a new book or updating a specific book’s data means more trips to the server at similar, purpose-defined URLs.

That’s the basic idea of two concepts we’ll be looking at here: GraphQL and Serverless.

GraphQL

Applications that do a lot of getting and updating of data make a lot of API calls. Complicated software, like Twitter, might make hundreds of calls to get the data for a single page. Collecting the right data from a handful of URLs and formatting it can be a real headache. In 2012, Facebook developers starting looking for new ways to get and update data more efficiently.

Their key insight was that for the most part, data in complicated applications has relationships to other data. A user has followers, who are each users themselves, who each have their own followers, and those followers have tweets, which have replies from other users. Drawing the relationships between data results in a graph and that graph can help a server do a lot of clever work formatting and sending (or updating) data, and saving front-end developers time and frustration. Graph Query Language, aka GraphQL, was born.

GraphQL is different from the REST API approach in its use of URLs and queries. To get a list of books from our API using GraphQL, we don’t need to go to a specific URL (like our api.example.com/graphql/books example). Instead, we call up the API at the top level — which would be api.example.com/graphql in our example — and tell it what kind of information we want back with a JSON object:

{
  books {
    id
    title
    author
  }
}

The server sees that request, formats our data, and sends it back in another JSON object:

{
  "books" : [
    {
      "id" : 123
      "title" : "The Greatest CSS Tricks Vol. I"
      "author" : "Chris Coyier"
    }, {
      // ...
    }
  ]
}

Sebastian Scholl compares GraphQL to REST using a fictional cocktail party that makes the distinction super clear. The bottom line: GraphQL allows us to request the exact data we want while REST gives us a dump of everything at the URL.

Concept 2: Serverless

Whenever I see the word “serverless,” I think of Chris Watterston’s famous sticker.

Similarly, there is no such thing as a truly “serverless” application. Chris Coyier nice sums it up his “Serverless” post:

What serverless is trying to mean, it seems to me, is a new way to manage and pay for servers. You don’t buy individual servers. You don’t manage them. You don’t scale them. You don’t balance them. You aren’t really responsible for them. You just pay for what you use.

The serverless approach makes it easier to build and deploy back-end applications. It’s especially easy for folks like me who don’t have a background in back-end development. Rather than spend my time learning how to provision and maintain a server, I often hand the hard work off to someone (or even perhaps something) else.

It’s worth checking out the CSS-Tricks guide to all things serverless. On the Ideas page, there’s even a link to a tutorial on building a serverless API!

Picking our tools

If you browse through that serverless guide you’ll see there’s no shortage of tools and resources to help us on our way to building an API. But exactly which ones we use requires some initial thought and planning. I’m going to cover two specific tools that we’ll use for our read-only API.

Tool 1: NodeJS and Express

Again, I don’t have much experience with back-end web development. But one of the few things I have encountered is Node.js. Many of you are probably aware of it and what it does, but it’s essentially JavaScript that runs on a server instead of a web browser. Node.js is perfect for someone coming from the front-end development side of things because we can work directly in JavaScript — warts and all — without having to reach for some back-end language.

Express is one of the most popular frameworks for Node.js. Back before React was king (How Do You Do, Fellow Kids?), Express was the go-to for building web applications. It does all sorts of handy thing like routing, templating, and error handling.

I’ll be honest: frameworks like Express intimidate me. But for a simple API, Express is extremely easy to use and understand. There’s an official GraphQL helper for Express, and a plug-and-play library for making a serverless application called serverless-http. Neat, right?!

Tool 2: Netlify functions

The idea of running an application without maintaining a server sounds too good to be true. But check this out: not only can you accomplish this feat of modern sorcery, you can do it for free. Mind blowing.

Netlify offers a free plan with serverless functions that will give you up to 125,000 API calls in a month. Amazon offers a similar service called Lambda. We’ll stick with Netlify for this tutorial.

Netlify includes Netlify Dev which is a CLI for Netlify’s platform. Essentially, it lets us run a simulation of our in a fully-featured production environment, all within the safety of our local machine. We can use it to build and test our serverless functions without needing to deploy them.

At this point, I think it’s worth noting that not everyone agrees that running Express in a serverless function is a good idea. As Paul Johnston explains, if you’re building your functions for scale, it’s best to break each piece of functionality out into its own single-purpose function. Using Express the way I have means that every time a request goes to the API, the whole Express server has to be booted up from scratch — not very efficient. Deploy to production at your own risk.

Let’s get building!

Now that we have out tools in place, we can kick off the project. Let’s start by creating a new folder, navigating to fit in terminal, then running npm init on it. Once npm creates a package.json file, we can install the dependencies we need. Those dependencies are:

1. Express
2. GraphQL and express-graphql. These allow us to receive and respond to GraphQL requests.
3. Bodyparser. This is a small layer that translates the requests we get to and from JSON, which is what GraphQL expects.
4. Serverless-http. This serves as a wrapper for Express that makes sure our application can be used on a serverless platform, like Netlify.

That’s it! We can install them all in a single command:

npm i express express-graphql graphql body-parser serverless-http

We also need to install Netlify Dev as a global dependency so we can use it as a CLI:

npm i -g netlify-dev

File structure

There’s a few files that are required for our API to work correctly. The first is netlify.toml which should be created at the project’s root directory. This is a configuration file to tell Netlify how to handle our project. Here’s what we need in the file to define our startup command, our build command and where our serverless functions are located:

[build]


  # This command builds the site
  command = "npm run build"


  # This is the directory that will be deployed
  publish = "build"


  # This is where our functions are located
  functions = "functions"

That functions line is super important; it tells Netlify where we’ll be putting our API code.

Next, let’s create that /functions folder at the project’s root, and create a new file inside it called api.js. Open it up and add the following lines to the top so our dependencies are available to use and are included in the build:

const express = require("express");
const bodyParser = require("body-parser");
const expressGraphQL = require("express-graphql");
const serverless = require("serverless-http");

Setting up Express only takes a few lines of code. First, we’ll initial Express and wrap it in the serverless-http serverless function:

const app = express();
module.exports.handler = serverless(app);

These lines initialize Express, and wrap it in the serverless-http function. module.exports.handler lets Netlify know that our serverless function is the Express function.

Now let’s configure Express itself:

app.use(bodyParser.json());
app.use(
  "/",
  expressGraphQL({
    graphiql: true
  })
);

These two declarations tell Express what middleware we’re running. Middleware is what we want to happen between the request and response. In our case, we want to parse JSON using bodyparser, and handle it with express-graphql. The graphiql:true configuration for express-graphql will give us a nice user interface and playground for testing.

Defining the GraphQL schema

In order to understand requests and format responses, GraphQL needs to know what our data looks like. If you’ve worked with databases then you know that this kind of data blueprint is called a schema. GraphQL combines this well-defined schema with types — that is, definitions of different kinds of data — to work its magic.

The very first thing our schema needs is called a root query. This will handle any data requests coming in to our API. It’s called a “root” query because it’s accessed at the root of our API— say, api.example.com/graphql.

For this demonstration, we’ll build a hello world example; the root query should result in a response of “Hello world.”

So, our GraphQL API will need a schema (composed of types) for the root query. GraphQL provides some ready-built types, including a schema, a generic object², and a string.

Let’s get those by adding this below the imports:

const {
  GraphQLSchema,
  GraphQLObjectType,
  GraphQLString
} = require("graphql");

Then we’ll define our schema like this:

const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'HelloWorld',
    fields: () => ({ /* we'll put our response here */ })
  })
})

The first element in the object, with the key query, tells GraphQL how to handle a root query. Its value is a GraphQL object with the following configuration:

• name – A reference used for documentation purposes
• fields – Defines the data that our server will respond with. It might seem strange to have a function that just returns an object here, but this allows us to use variables and functions defined elsewhere in our file without needing to define them first³.

const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: "HelloWorld",
    fields: () => ({
      message: {
        type: GraphQLString,
        resolve: () => "Hello World",
      },
    }),
  }),
});

The fields function returns an object and our schema only has a single message field so far. The message we want to respond with is a string, so we specify its type as a GraphQLString. The resolve function is run by our server to generate the response we want. In this case, we’re only returning “Hello World” but in a more complicated application, we’d probably use this function to go to our database and retrieve some data.

That’s our schema! We need to tell our Express server about it, so let’s open up api.js and make sure the Express configuration is updated to this:

app.use(
  "/",
  expressGraphQL({
    schema: schema,
    graphiql: true
  })
);

Running the server locally

Believe it or not, we’re ready to start the server! Run netlify dev in Terminal from the project’s root folder. Netlify Dev will read the netlify.toml configuration, bundle up your api.js function, and make it available locally from there. If everything goes according to plan, you’ll see a message like “Server now ready on http://localhost:8888.”

If you go to localhost:8888 like I did the first time, you might be a little disappointed to get a 404 error.

But fear not! Netlify is running the function, only in a different directory than you might expect, which is /.netlify/functions. So, if you go to localhost:8888/.netlify/functions/api, you should see the GraphiQL interface as expected. Success!

The screen we get is the GraphiQL playground and we can use it to test out the API. First, clear out the comments in the left pane and replace them with the following:

{
  message
}

This might seem a little… naked… but you just wrote a GraphQL query! What we’re saying is that we’d like to see the message field we defined in api.js. Click the “Run” button, and on the righth, you’ll see the following:

{
  "data": {
    "message": "Hello World"
  }
}

I don’t know about you, but I did a little fist pump when I did this the first time. We built an API!

Bonus: Redirecting requests

One of my hang-ups while learning about Netlify’s serverless functions is that they run on the /.netlify/functions path. It wasn’t ideal to type or remember it and I nearly bailed for another solution. But it turns out you can easily redirect requests when running and deploying on Netlfiy. All it takes is creating a file in the project’s root directory called _redirects (no extension necessary) with the following line in it:

/api /.netlify/functions/api 200!

This tells Netlify that any traffic that goes to yoursite.com/api should be sent to /.netlify/functions/api. The 200! bit instructs the server to send back a status code of 200 (meaning everything’s OK).

Deploying the API

To deploy the project, we need to connect the source code to Netlfiy. I host mine in a GitHub repo, which allows for continuous deployment.

After connecting the repository to Netlfiy, the rest is automatic: the code is processed and deployed as a serverless function! You can log into the Netlify dashboard to see the logs from any function.

Conclusion

Just like that, we are able to create a serverless API using GraphQL with a few lines of JavaScript and some light configuration. And hey, we can even deploy — for free.

The possibilities are endless. Maybe you want to create your own personal knowledge base, or a tool to serve up design tokens. Maybe you want to try your hand at making your own PokéAPI. Or, maybe you’re interesting in working with GraphQL.

Regardless of what you make, it’s these sorts of technologies that are getting more and more accessible every day. It’s exciting to be able to work with some of the most modern tools and techniques without needing a deep technical back-end knowledge.

If you’d like to see at the complete source code for this project, it’s available on GitHub.

Some of the code in this tutorial was adapted from Web Dev Simplified’s “Learn GraphQL in 40 minutes” article. It’s a great resource to go one step deeper into GraphQL. However, it’s also focused on a more traditional server-full Express.

The post Building Serverless GraphQL API in Node with Express and Netlify appeared first on CSS-Tricks.

A couple of WordPress contributors are currently looking for folks to sponsor them to work on the documentation for the WordPress block editor (often referred to as “Gutenberg”) and this is your chance to support them.

If you’ve developed blocks for the WordPress block editor — or at least have tried to — then you have likely struggled to find any meaningful documentation. Heck, just look at two recent posts here at CSS-Tricks where Dmitry Mayorov explains block variations and Leonardo Losoviz adds a welcome guide to the block editor. They both lament the lack of documentation and describe how they had to work around it. Chris has even experimented with different build approaches, from create-gluten-block to wp-cli to ACF Blocks. It’s sortuva Wild West out there and documented standards with examples would be a huge win, both for WordPress and for developers.

Now, I don’t think it’s worth getting into a debate into why the documentation doesn’t already exist a year since the block editor was released. There are lots of reasons for that and none of them help move things forward.

We flipped the switch to enable the WordPress block editor here at CSS-Tricks earlier this year and haven’t looked back. Where several of us on the team would write drafts in Dropbox Paper, Google Docs, or even a code editor, I think we’ve all started writing directly in WordPress because, well, it’s just so gosh-darned nice. I know I’m looking forward to contributing whatever I can to help this make this tool more accessible to developers — that’s the best way to spark new ideas and innovations for the future of blocks.

Direct Link to Article — Permalink

The post WordPress Contributors Seek Sponsorship for Improving Gutenberg Developer Docs appeared first on CSS-Tricks.

gatsby new gatsby-source-comment-server https://github.com/Gatsbyjs/gatsby-starter-plugin

npm install axios --save
// or
yarn add axios

exports.sourceNodes = async ({ actions }) => {
  const { createTypes } = actions;
  const typeDefs = `
    type CommentServer implements Node {
      _id: String
      author: String
      string: String
      content: String
      website: String
      slug: String
      createdAt: Date
      updatedAt: Date
    }
  `;
  createTypes(typeDefs);
};

const axios = require("axios");

exports.sourceNodes = async (
  { actions, createNodeId, createContentDigest },
  pluginOptions
) => {
  const { createTypes } = actions;
  const typeDefs = `
    type CommentServer implements Node {
      _id: String
      author: String
      string: String
      website: String
      content: String
      slug: String
      createdAt: Date
      updatedAt: Date
    }
  `;
  createTypes(typeDefs);

  const { createNode } = actions;
  const { limit, website } = pluginOptions;
  const _website = website || "";

  const result = await axios({
    url: `https://Gatsbyjs-comment-server.herokuapp.com/comments?limit=${_limit}&website=${_website}`,
  });

  const comments = result.data;

  function convertCommentToNode(comment, { createContentDigest, createNode }) {
    const nodeContent = JSON.stringify(comment);

    const nodeMeta = {
      id: createNodeId(`comments-${comment._id}`),
      parent: null,
      children: [],
      internal: {
        type: `CommentServer`,
        mediaType: `text/html`,
        content: nodeContent,
        contentDigest: createContentDigest(comment),
      },
    };

    const node = Object.assign({}, comment, nodeMeta);
    createNode(node);
  }

  for (let i = 0; i < comments.data.length; i++) {
    const comment = comments.data[i];
    convertCommentToNode(comment, { createNode, createContentDigest });
  }
};

exports.createResolvers = ({ createResolvers }) => {
  const resolvers = {
    MarkdownRemark: {
      comments: {
        type: ["CommentServer"],
        resolve(source, args, context, info) {
          return context.nodeModel.runQuery({
            query: {
              filter: {
                slug: { eq: source.fields.slug },
              },
            },
            type: "CommentServer",
            firstOnly: false,
          });
        },
      },
    },
  };
  createResolvers(resolvers);
};

const axios = require("axios");

exports.sourceNodes = async (
  { actions, createNodeId, createContentDigest },
  pluginOptions
) => {
  const { createTypes } = actions;
  const typeDefs = `
    type CommentServer implements Node {
      _id: String
      author: String
      string: String
      website: String
      content: String
      slug: String
      createdAt: Date
      updatedAt: Date
    }
  `;
  createTypes(typeDefs);

  const { createNode } = actions;
  const { limit, website } = pluginOptions;
  const _limit = parseInt(limit || 10000); // FETCH ALL COMMENTS
  const _website = website || "";

  const result = await axios({
    url: `https://Gatsbyjs-comment-server.herokuapp.com/comments?limit=${_limit}&website=${_website}`,
  });

  const comments = result.data;

  function convertCommentToNode(comment, { createContentDigest, createNode }) {
    const nodeContent = JSON.stringify(comment);

    const nodeMeta = {
      id: createNodeId(`comments-${comment._id}`),
      parent: null,
      children: [],
      internal: {
        type: `CommentServer`,
        mediaType: `text/html`,
        content: nodeContent,
        contentDigest: createContentDigest(comment),
      },
    };

    const node = Object.assign({}, comment, nodeMeta);
    createNode(node);
  }

  for (let i = 0; i < comments.data.length; i++) {
    const comment = comments.data[i];
    convertCommentToNode(comment, { createNode, createContentDigest });
  }
};

exports.createResolvers = ({ createResolvers }) => {
  const resolvers = {
    MarkdownRemark: {
      comments: {
        type: ["CommentServer"],
        resolve(source, args, context, info) {
          return context.nodeModel.runQuery({
            query: {
              filter: {
                website: { eq: source.fields.slug },
              },
            },
            type: "CommentServer",
            firstOnly: false,
          });
        },
      },
    },
  };
  createResolvers(resolvers);
};

import fs from "fs"
import {resolve: pathResolve} from "path"
exports.createPagesStatefully = async ({ graphql }) => {
  const comments = await graphql(
    `
      {
        allCommentServer(limit: 1000) {
          edges {
            node {
              name
              slug
              _id
              createdAt
              content
            }
          }
        }
      }
    `
  )

  if (comments.errors) {
    throw comments.errors
  }

  const markdownPosts = await graphql(
    `
      {
        allMarkdownRemark(
          sort: { fields: [frontmatter___date], order: DESC }
          limit: 1000
        ) {
          edges {
            node {
              fields {
                slug
              }
            }
          }
        }
      }
    `
  )

  const posts = markdownPosts.data.allMarkdownRemark.edges
  const _comments = comments.data.allCommentServer.edges

  const commentsPublicPath = pathResolve(process.cwd(), "public/comments")

  var exists = fs.existsSync(commentsPublicPath) //create destination directory if it doesn't exist

  if (!exists) {
    fs.mkdirSync(commentsPublicPath)
  }

  posts.forEach((post, index) => {
    const path = post.node.fields.slug
    const commentsForPost = _comments
      .filter(comment => {
        return comment.node.slug === path
      })
      .map(comment => comment.node)

    const strippedPath = path
      .split("/")
      .filter(s => s)
      .join("/")
    const _commentPath = pathResolve(
      process.cwd(),
      "public/comments",
      `${strippedPath}.json`
    )
    fs.writeFileSync(_commentPath, JSON.stringify(commentsForPost))
  })
}

exports.onRouteUpdate = async (apiHelpers, pluginOptions) => {
  const { location, prevLocation } = apiHelpers
}

// Creates element, set class. innerhtml then returns it.
 function createEl (name, className, html = null) {
  const el = document.createElement(name)
  el.className = className
  el.innerHTML = html
  return el
}

// ...

exports.onRouteUpdate = async ({ location, prevLocation }, pluginOptions) => {
  const commentContainer = document.getElementById("commentContainer")
  if (commentContainer && location.path !== "/") {
    const header = createEl("h2")
    header.innerHTML = "Comments"
    commentContainer.appendChild(header)
  }
}

exports.onRouteUpdate = async ({ location, prevLocation }, pluginOptions) => {
  const commentContainer = document.getElementById("commentContainer")
  if (commentContainer && location.path !== "/") {
    const header = createEl("h2")
    header.innerHTML = "Comments"
    commentContainer.appendChild(header)
    const commentListUl = createEl("ul")
    commentListUl.className = "comment-list"
    commentContainer.appendChild(commentListUl)
}

// Other helpers
const getCommentsForPage = async slug => {
  const path = slug
    .split("/")
    .filter(s => s)
    .join("/")
  const data = await fetch(`/comments/${path}.json`)
  return data.json()
}
// ... implements routeupdate below

// ... helpers
exports.onRouteUpdate = async ({ location, prevLocation }, pluginOptions) => {
  const commentContainer = document.getElementById("commentContainer")
  if (commentContainer && location.path !== "/") {
    //... inserts header
    const commentListUl = createEl("ul")
    commentListUl.className = "comment-list"
    commentContainer.appendChild(commentListUl)
   const comments = await getCommentsForPage(location.pathname)
}

// .... other helpers

const getCommentListItem = comment => {
  const li = createEl("li")
  li.className = "comment-list-item"

  const nameCont = createEl("div")
  const name = createEl("strong", "comment-author", comment.name)
  const date = createEl(
    "span",
    "comment-date",
    new Date(comment.createdAt).toLocaleDateString()
  )
  // date.className="date"
  nameCont.append(name)
  nameCont.append(date)

  const commentCont = createEl("div", "comment-cont", comment.content)

  li.append(nameCont)
  li.append(commentCont)
  return li
}

// ... onRouteUpdateImplementation

// ... helpers
exports.onRouteUpdate = async ({ location, prevLocation }, pluginOptions) => {
  const commentContainer = document.getElementById("commentContainer")
  if (commentContainer && location.path !== "/") {
    //... inserts header
    const commentListUl = createEl("ul")
    commentListUl.className = "comment-list"
    commentContainer.appendChild(commentListUl)
   const comments = await getCommentsForPage(location.pathname)
    if (comments && comments.length) {
      comments.map(comment => {
        const html = getCommentListItem(comment)
        commentListUl.append(html)
        return comment
      })
    }
}

// ... other helpers
const createCommentForm = () => {
  const form = createEl("form")
  form.className = "comment-form"
  const nameInput = createEl("input", "name-input", null)
  nameInput.type = "text"
  nameInput.placeholder = "Your Name"
  form.appendChild(nameInput)
  const commentInput = createEl("textarea", "comment-input", null)
  commentInput.placeholder = "Comment"
  form.appendChild(commentInput)
  const feedback = createEl("span", "feedback")
  form.appendChild(feedback)
  const button = createEl("button", "comment-btn", "Submit")
  button.type = "submit"
  form.appendChild(button)
  return form
}

// ... helpers
exports.onRouteUpdate = async ({ location, prevLocation }, pluginOptions) => {
  const commentContainer = document.getElementById("commentContainer")
  if (commentContainer && location.path !== "/") {
    // insert header
    // insert comment list
    commentContainer.appendChild(createCommentForm())
  }
}

// ... other helpers
// Sets the class and text of the form feedback
const updateFeedback = (str = "", className) => {
  const feedback = document.querySelector(".feedback")
  feedback.className = `feedback ${className ? className : ""}`.trim()
  feedback.innerHTML = str
  return feedback
}
// onRouteUpdate callback

exports.onRouteUpdate = async ({ location, prevLocation }, pluginOptions) => {
  // Appends header
  // Appends comment list
  // Appends comment form
  document
    .querySelector("body .comment-form")
    .addEventListener("submit", async function (event) {
      event.preventDefault()
      updateFeedback()
      const name = document.querySelector(".name-input").value
      const comment = document.querySelector(".comment-input").value
      if (!name) {
        return updateFeedback("Name is required")
      }
      if (!comment) {
        return updateFeedback("Comment is required")
      }
      updateFeedback("Saving comment", "info")
      const btn = document.querySelector(".comment-btn")
      btn.disabled = true
      const data = {
        name,
        content: comment,
        slug: location.pathname,
        website: pluginOptions.website,
      }

      fetch(
        "https://cors-anywhere.herokuapp.com/gatsbyjs-comment-server.herokuapp.com/comments",
        {
          body: JSON.stringify(data),
          method: "POST",
          headers: {
            Accept: "application/json",
            "Content-Type": "application/json",
          },
        }
      ).then(async function (result) {
        const json = await result.json()
        btn.disabled = false

        if (!result.ok) {
          updateFeedback(json.error.msg, "error")
        } else {
          document.querySelector(".name-input").value = ""
          document.querySelector(".comment-input").value = ""
          updateFeedback("Comment has been saved!", "success")
        }
      }).catch(async err => {
        const errorText = await err.text()
        updateFeedback(errorText, "error")
      })
    })
}

#commentContainer {
}

.comment-form {
  display: grid;
}

import "./style.css"

// PARENT
// ├── PLUGIN
// ├── Gatsby Website

gatsby new private-blog https://github.com/gatsbyjs/gatsby-starter-blog

cd /path/to/blog
npm link ../path/to/plugin/folder

module.exports = {
  // ...
  plugins: [
    // ...
    "gatsby-plugin-dom-injector",
    {
      resolve: "gatsby-comment-server-plugin",
      options: {website: "https://url-of-website.com"},
    },
  ],
}

Any time I chat with a fellow web person and CSS-Tricks comes up in conversation, there is a good chance they’ll say: oh yeah, that guide on CSS flexbox, I use that all the time!

Indeed that page, and it’s cousin the CSS grid guide, are among our top trafficked pages. I try to take extra care with them making sure the information on them is current, useful, and the page loads speedily and properly. A while back, in a round of updates I was doing on the guides, I reached out to Lynn Fisher, who always does incredible work on everything, to see if she’d be up for re-doing the illustrations on the guides. Miraculously, she agreed, and we have the much more charismatic illustrations that live on the guides today.

In a second miracle, I asked Lynn again if she’d be up for making physical paper poster designs of the guides, and see agreed again! And so they live!

Here they are:

You better believe I have it right next to me in my office:

They are $25 each which includes shipping anywhere in the world.

The post Posters! (for CSS Flexbox and CSS Grid) appeared first on CSS-Tricks.