Normally your response JSON contains data property. We just simply retrive data with simple format.

const { data } = response; // data = true
if(data){
// do something
}

Well, it is not well format. As a best practice, it is better to respond with well format.

const { data } = response;
const { isAvailable } = data; // data: { isAvailable: true }
if(data){
// do something
}

Normally you expect some functions to throw errors, you write this:

async function foo(){
throw new Error('some error');
}
test('catch throws', async ()=>{
const result = await foo();
expect(result).toThrow();
});

Well, it does not work.

But this works:

async function foo(){
throw new Error('some error');
}
test('catch throw', async ()=>{
const result = ()=> await foo();
expect(result).rejects.toThrow();
});
  • Expectation needs a function argument.
  • Prefix method is followed after toThrow() .

Read more at https://jestjs.io/docs/en/asynchronous#resolves-rejects


If you are trying to send cookies in http header in different ports or domain, you will need to allow withCredential: true in your CORS policy in your Express middleware.

app.use(cors({
origin: 'http://localhost:3000',
methods: ['POST', 'PUT', 'GET', 'OPTIONS', 'HEAD'],
credentials: true
}));
// to enable CORS using credentials

`withCredentials` indicates whether or not cross-site Access-Control requests should be made using credentials.

For multiple arrays of whitelists,

const whitelist = [
'http://localhost:3000',
'http://localhost:4000'];
const corsOptionsDelegate = function (req: any, callback: any) { let corsOptions; if (whitelist.indexOf(req.header('Origin')) !== -1) { corsOptions = { origin: true, methods: ['POST', 'PUT', 'GET', 'OPTIONS', 'HEAD'], credentials…

Follow this tutorial:

  • Select existing project.
  • Search API & Services.
  • Enable API & Services.
  • Enable Google Drive API.
  • Create a Service Account.
  • Go to IAM & Account > Service Account > Keys > Add Keys > Create a new key > JSON > Downloaded.

Then, you will have a JSON file associated with your service account.

  • If you want to set configs in Firebase on Mac,
firebase functions:config:set configName="$(cat service-account.json)"

ကျိုးကြောင်းပြ တွေးခေါ်မှု

ခင်ဗျားတို့ကို စစ်ပွဲရဲ့ အပူထဲက စစ်သားတစ်ယောက်လို့ ခဏလောက် မြင်ကြည့်စေချင်တယ်။ ခင်ဗျာဟာ ရောမ ခြေလျင် စစ်သား (သို့) အလယ်ခေတ် မျှားစစ်သည် (သို့) ဇူးလူး စစ်သည်တော် ဆိုပါစို့။ တိုက်ပွဲထဲ ရောက်နေတဲ့ ခင်ဗျားရဲ့ Adrenaline က မြင့်နေပြီး မိမိကိုယ်ကိုနဲ့ မိမိဘက်ကို ကာကွယ်ဖို့၊ ရန်သူကို အနိုင်တိုက်ဖို့ လိုအပ်ချက်ထဲက အမြစ်တွယ်နေတဲ့ ``နက်ရှိုင်းစွာ ချိုးကပ်နေတဲ့ အလိုလိုတုန့်ပြန်မှု``တွေက စိတ်လှုပ်ရှားမှုတွေဟာ အစပြုနေတယ်။

နောက်တစ်မျိုးအနေနဲ့ ခင်ဗျားဟာ ကင်းထောက်ဆိုတဲ့ သိပ်ကို ကွဲပြားတဲ့ အခန်းမှာ သရုပ်ဆောင်တာ မြင်ကြည့်စေချင်တယ်။ ကင်းထောက်ရဲ့ အလုပ်က တိုက်ခိုက်ဖို့ (သို့) ကာကွယ်ဖို့ မဟုတ်ဘူး။ ကင်းထောက်ရဲ့ အလုပ်က အပြင်ထွက်၊ နယ်မြေအနေအထားကို မြေပုံထုတ်၊ ပေါ်လာနိုင်တဲ့ အတား အဆီးတွေကို ရှာဖွေတဲ့ သူပါ။ ကင်းထောက် သိထားရမှာက မျှော်လင့်ထားရမှာက မြစ်ကိုကူးဖို့ ဘယ်နေရာမှာ အဆင်ပြေပြီး ဘယ်နေရာမှာ တံတားတစ်စင်းရှိလဲဆိုတာတွေပေါ့။ ဒါပေမဲ့ ဒါတွေအားလုံးထက် ကင်းထောက်ဟာ အဲဒီမှာ ဘာရှိလဲဆိုတာ ဖြစ်နိုင်သလောက် အတိအကျ သိချင်တယ်။ တကယ့် စစ်တပ်မှာတော့ စစ်သားရော ကင်းထောက်ပါ နှစ်ခုစလုံး မရှိမဖြစ်ပါ။

ဒီကဏ္ဍတစ်ခုစီက ကင်းထောက်နဲ့ စစ်သားတစ်ယောက်ရဲ့ စိတ်သဘောထား (၂)ခုကို သုံသပ်ကြည့်လို့ရပါတယ်။…


In a pre-order traversal, the root node of the tree is processed first, then the left subtree is traversed, then the right subtree.

In a post-order traversal, the left subtree is traversed, then the right subtree, and then the root node is processed.

In an in-order traversal, the left subtree is traversed first, then the root node is processed, then the right subtree is traversed.

Well, it is not meaningful but complexly meaningful.

Watch this video. It will clear its definitions.

Simply,

  • In pre-order traversal, sequence is started at the left free subtree of a node and continued at…

A robust program is one that can handle errors and other unexpected conditions in some reasonable way. This means that the program must anticipate possible errors and respond to them if they occur.

ဆိုလိုတာက Robust program တစ်ခုသည် အကျိုးအကြောင်း စီလျော်စွာ error handling, exception handling လုပ်ပေးနိုင်ရမယ်။

Then, Why should a subroutine throw an exception when it encounters an error? Why not just terminate the program?

Terminating the program is too drastic, and this tactic certainly doesn’t lead to robust programs! It’s likely that the subroutine doesn’t know what to do with the error, but that doesn’t mean that it should abort the…


Rename ColDef to GridColDef .

For example,

import { 
DataGrid,
GridColDef,
ValueGetterParams
} from "@material-ui/data-grid";


A data stored in HTTP header with httpOnly options will be stored only in the HTTP header.

For example, if you store cookies with httpOnly options, your cookies will be stored only in HTTP header. You cannot retrieved it with JavaScript API. You cannot check it by client side API. But your client can request to server with its header.

In server-side, you can retrieve cookie header with this request.

request.cookie

Have you tried this?

const app = express();
app.use(cors());

Yeah. You have seen this solution commonly.

Then, have you tried this in your request query?

axios.get('http:localhost:7000/items')

I mean http.

If you are specifying url in .env like this, instead of this:

REACT_APP_API_URL=localhost:7000

Always add http or https if SSL enabled.

REACT_APP_API_URL=http:localhost:7000

Cing Sian Dal

Don’t follow me. I wrote junks here. Follow me on Twitter instead.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store