DummyJSON VS httpbin

# next auth secret created by open ssl NEXTAUTH_SECRET=8xvug0aweP+j06DbfOLH9fAU7Bf2nLBLnYHQiFPB9Pc= #local NEXTAUTH_URL="http://localhost:3000" NEXT_PUBLIC_API_URL="https://dummyjson.com" # deveploment NEXTAUTH_DEBUG=true

import { useAuth } from "@clerk/nextjs"; import axios, { AxiosError, isAxiosError } from "axios"; interface GraphQLResponse { data: T; errors?: { message: string }[]; } export const useFetchGraphQLData = ( query: string ): ((variables?: TVariables) => Promise) => { const { getToken } = useAuth(); const url = "https://dummyjson.com"; // Replace this with your GraphQL API URL return async (variables?: TVariables) => { const token = await getToken(); try { const response = await axios.post>( url, { query, variables, }, { headers: { "Content-Type": "application/json", Authorization: token ? `Bearer ${token}` : "", }, } ); if (response.data.errors) { throw new Error(response.data.errors[0].message); } return response.data.data; } catch (error) { if (isAxiosError(error)) { const serverError = error as AxiosError>; if (serverError && serverError.response) { const errorMessage = serverError.response.data.errors?.[0]?.message || "Error in GraphQL request"; throw new Error(errorMessage); } } throw error; } }; };

DummyJSON is a set of endpoints you can use to try out different requests without using a commercial API which may or may not ban you or limit your access..

This particular interface was built around https://dummyjson.com/ fake REST API.

https://dummyjson.com has a few good endpoints for building out basic apps.

Buenas te dejo algunas que conozco https://dummyjson.com/ https://www.jsonapi.co/public-api https://github.com/public-apis/public-apis

I've been using https://dummyjson.com/ to prototype my Web Components, but this probably works better.

I will use DummyJSON, to get dummy/fake JSON data to use as placeholder in development and prototyping, without worrying about writing a backend.

import { NextPage } from 'next' import { useState } from 'react' import { setCookie } from 'cookies-next' import { useRouter } from 'next/router' import { useAuthStore } from '~/store/useAuthStore' // import our useAuthStore const SignIn: NextPage = (props) => { // set UserInfo state with inital values const [userInfo] = useState({ email: 'kminchelle', password: '0lelplR' }) const router = useRouter() // import state from AuthStore const setUser = useAuthStore((state) => state.setUser) const setAuthentication = useAuthStore((state) => state.setAuthentication) const login = async () => { // do a post call to the auth endpoint const res = await fetch('https://dummyjson.com/auth/login', { method: 'post', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ username: userInfo.email, password: userInfo.password, }), }) // check if response was ok if (!res.ok) { return console.error(res) } // retrieve data from the response const data = await res.json() // check if we have data if (data) { setUser(data) // set data to our user state setAuthentication(true) // set our authentication state to true setCookie('token', data?.token) // set token to the cookie router.push('/') // redirect to home page } } return (

Login

Username (userInfo.email = event.target.value)} required /> Password (userInfo.password = event.target.value)} name="psw" required /> Login

) } export default SignIn

import json import requests def lambda_handler(event, context): base_url = 'https://dummyjson.com/' product_id = '1' resp = requests.get(url=base_url+'products/'+product_id) if resp.status_code != 200: raise Exception('Failed to retrieve product: '+resp.text) return { 'statusCode': resp.status_code, 'body': resp.json() } Q. what this code does? 1.Imports the necessary modules (JSON and requests). 2.Defines a base URL and a product ID that will be used to construct the API URL. 3.Sends a GET request to the API using the requests library, passing in the full API URL. 4.Checks the response status code to make sure that the request was successful (status code 200). 5.If the response status code is not 200, raise an exception with an error message that includes the response text. 6.If the response status code is 200, return a dictionary containing the response status code and the parsed JSON response body. ●Test the function.

policyDefinitions: cors: origin: "${CLIENT_URL}" endpoints: - path: "/example" target: url: "https://httpbin.org/bearer" request: headers: Authorization: "Bearer ${API_KEY}" policies: - cors

We proceed to define routes to https://httpbin.org/ to test our setup. Let's call the route to /get:

https://httpbin.org/ is an excellent tool for learning (and testing) the basics. Take a few minutes to explore the endpoints they provide. You can also use different response codes to test your apps error handling, etc

export FABI_PROD="http://httpbin.org/" export FABI_LOCAL="http://0.0.0.0:8000/"

use anyhow; use embedded_svc::http::client::Client; use embedded_svc::wifi::{AuthMethod, ClientConfiguration, Configuration}; use esp_idf_hal::peripherals::Peripherals; use esp_idf_svc::eventloop::EspSystemEventLoop; use esp_idf_svc::http::client::{Configuration as HttpConfig, EspHttpConnection}; use esp_idf_svc::nvs::EspDefaultNvsPartition; use esp_idf_svc::wifi::{BlockingWifi, EspWifi}; fn main() -> anyhow::Result<()> { esp_idf_sys::link_patches(); // Configure Wifi let peripherals = Peripherals::take().unwrap(); let sysloop = EspSystemEventLoop::take()?; let nvs = EspDefaultNvsPartition::take()?; let mut wifi = BlockingWifi::wrap( EspWifi::new(peripherals.modem, sysloop.clone(), Some(nvs))?, sysloop, )?; wifi.set_configuration(&Configuration::Client(ClientConfiguration { ssid: "SSID".into(), bssid: None, auth_method: AuthMethod::None, password: "PASSWORD".into(), channel: None, }))?; // Start Wifi wifi.start()?; // Connect Wifi wifi.connect()?; // Wait until the network interface is up wifi.wait_netif_up()?; // Print Out Wifi Connection Configuration while !wifi.is_connected().unwrap() { // Get and print connection configuration let config = wifi.get_configuration().unwrap(); println!("Waiting for station {:?}", config); } println!("Wifi Connected, Intiatlizing HTTP"); // HTTP Configuration // Create HTTPS Connection Handle let httpconnection = EspHttpConnection::new(&HttpConfig { use_global_ca_store: true, crt_bundle_attach: Some(esp_idf_sys::esp_crt_bundle_attach), ..Default::default() })?; // Create HTTPS Client let mut httpclient = Client::wrap(httpconnection); // HTTP Request Submission // Define URL let url = "https://httpbin.org/get"; // Prepare request let request = httpclient.get(url)?; // Log URL and type of request println!("-> GET {}", url); // Submit Request and Store Response let response = request.submit()?; // HTTP Response Processing let status = response.status(); println!("<- {}", status); match response.header("Content-Length") { Some(data) => { println!("Content-Length: {}", data); } None => { println!("No Content-Length Header"); } } match response.header("Date") { Some(data) => { println!("Date: {}", data); } None => { println!("No Date Header"); } } Ok(()) }

has_domain: whether the matched route references an upstream with a domain, e.g., http://httpbin.org, or not, e.g., 192.168.0.1