20 ਸਤੰ 2025·8 ਮਿੰਟ
TJ Holowaychuk ਦੇ Express ਅਤੇ Koa: ਮਿਨੀਮਲ Node ਬੈਕਐਂਡ
TJ Holowaychuk ਦੇ Express ਅਤੇ Koa ਨੇ Node.js ਇਕੋਸਿਸਟਮ ਨੂੰ ਕਿਵੇਂ ਰੂਪ ਦਿੱਤਾ: ਮਿਨੀਮਲ ਮਿਡਲਵੇਅਰ, קומਪੋਜ਼ੇਬਲ APIs, ਅਤੇ ਰੱਖ-ਰਖਾਵ ਯੋਗ ਬੈਕਐਂਡ ਬਣਾਉਣ ਲਈ ਸਬਕ।
TJ Holowaychuk ਦੇ Express ਅਤੇ Koa ਨੇ Node.js ਇਕੋਸਿਸਟਮ ਨੂੰ ਕਿਵੇਂ ਰੂਪ ਦਿੱਤਾ: ਮਿਨੀਮਲ ਮਿਡਲਵੇਅਰ, קומਪੋਜ਼ੇਬਲ APIs, ਅਤੇ ਰੱਖ-ਰਖਾਵ ਯੋਗ ਬੈਕਐਂਡ ਬਣਾਉਣ ਲਈ ਸਬਕ।
TJ Holowaychuk Node.js ਕਮਿਊਨਿਟੀ ਦੇ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਇਮਾਰਤਕਾਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ। ਉਨ੍ਹਾਂ ਨੇ Express ਬਣਾਇਆ, ਐਸੇ ਪੈਟਰਨਾਂ ਨੂੰ ਪ੍ਰਸਿੱਧ ਕੀਤਾ ਜਿਨ੍ਹਾਂ ਨੇ Node ਵੈੱਬ ਐਪਸ ਦੇ ਲਿਖਣ ਦੇ ਢੰਗ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤਾ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ Koa ਇੱਕ ਨਵੀਂ ਸੋਚ ਦੇ ਤੌਰ 'ਤੇ ਪੇਸ਼ ਕੀਤਾ ਕਿ ਇੱਕ ਵੈੱਬ ਫਰੇਮਵਰਕ ਕੋਰ ਕਿਸ ਤਰ੍ਹਾਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਦਾ ਕੋਡ ਸਿੱਧਾ ਵਰਤਿਆ ਨਹੀਂ ਭੀ ਹੈ, ਫਿਰ ਵੀ ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਦਾ ਪ੍ਰਭਾਵ ਮਹਿਸੂਸ ਹੋਇਆ ਹੋਵੇਗਾ: ਕਈ Node.js ਫਰੇਮਵਰਕ, ਟਿਊਟੋਰਿਅਲ, ਅਤੇ ਪ੍ਰੋਡਕਸ਼ਨ ਬੈਕਐਂਡ ਇਨ੍ਹਾਂ ਵਿਚਾਰਾਂ ਨੂੰ ਉਤਰਦੇ ਹਨ ਜੋ Express ਅਤੇ Koa ਨੇ ਮੈਨਸਟਰੀਮ ਬਣਾਏ।
Express ਅਤੇ Koa "ਮਿਨੀਮਲ" ਇੱਕ ਖਾਸ ਤਰੀਕੇ ਨਾਲ ਹਨ: ਇਹ ਹਰ ਫੈਸਲਾ ਤੁਹਾਡੇ ਲਈ ਨਹੀਂ ਕਰਦੇ। ਪੂਰੀਆਂ ਰਾਇਆਂ—authentication, ਡੈਟਾਬੇਸ ਨਿਯਮ, ਬੈਕਗਰਾਉਂਡ ਜਾਬਜ਼, admin panel—ਨੂੰ ਬੰਡਲ ਕਰਨ ਦੀ ਥਾਂ, ਇਹ HTTP ਬੇਨਤੀ ਅਤੇ ਜਵਾਬ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਛੋਟਾ, ਭਰੋਸੇਯੋਗ ਕੋਰ ਦਿੰਦੇ ਹਨ।
ਇਸਨੂੰ ਇੱਕ ਚੰਗੀ ਤਰੀਕੇ ਨਾਲ ਬਣੀ ਟੂਲਬਾਕਸ ਵਾਂਗ ਸੋਚੋ, ਨਾ ਕਿ ਪਹਿਲਾਂ ਤੋਂ ਫਰਨਿਚਰ ਕੀਤੀ ਹੋਈ ਘਰ। ਫਰੇਮਵਰਕ ਤੁਹਾਨੂੰ ਫੀਚਰ (routing, validation, cookies, sessions) ਜੋੜਨ ਲਈ ਸਾਫ ਥਾਂ ਦਿੰਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਫੈਸਲਾ ਕਰਦੇ ਹੋ ਕਿ ਕਿਹੜੇ ਹਿੱਸੇ ਲੋੜੀਂਦੇ ਹਨ ਅਤੇ ਉਹ ਕਿਵੇਂ ਫਿੱਟ ਹੁੰਦੇ ਹਨ।
ਇਹ ਪੋਸਟ ਪ੍ਰਿਕਟਿਕਲ ਤੌਰ ਤੇ ਉਹ ਗੱਲਾਂ ਦੱਸਦੀ ਹੈ ਜੋ Express ਅਤੇ Koa ਨੂੰ ਸਥਿਰ ਬਣਾਉਂਦੀਆਂ ਹਨ:
ਔਖਾ ਇੱਕ ਪ੍ਰਾਜੈਕਟ ਦੀ ਲੋੜਾਂ (ਟੀਮ ਦਾ ਆਕਾਰ, ਜਟਿਲਤਾ, ਲੰਬੇ ਸਮੇਂ ਦੀ ਰੱਖਿਆ) ਵੇਖ ਕੇ ਤੁਹਾਨੂੰ ਘੱਟ ਅਚਾਨਕ ਚੀਜ਼ਾਂ ਵਾਲੀ ਦਿੱਖ ਚੁਣਨ ਵਿੱਚ ਮਦਦ ਮਿਲੇਗੀ।
Node.js ਨੇ ਬਹੁਤ ਸਾਰੀਆਂ ਟੀਮਾਂ ਲਈ "ਬੈਕਐਂਡ ਡਿਵੈਲਪਮੈਂਟ" ਦਾ ਅਨੁਭਵ ਬਦਲ ਦਿੱਤਾ। ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ JavaScript ਅਤੇ ਸਰਵਰ ਤੇ ਇਕ ਹੋਰ ਭਾਸ਼ਾ ਦੇ ਬਦਲੇ, ਤੁਸੀਂ ਇਕੋ ਭਾਸ਼ਾ ਵਿੱਚ end-to-end ਬਣਾਉਂ ਸਕਦੇ ਹੋ, ਸੋਚ-ਮਾਡਲ ਸਾਂਝੇ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਵਿਚਾਰ ਤੋਂ ਕੰਮ ਕਰਦੇ endpoint ਤੱਕ ਜਾ ਸਕਦੇ ਹੋ।
ਇਸ ਨਾਲ ਕੰਮ ਦੀ ਰਫ਼ਤਾਰ ਹੀ ਨਹੀਂ ਵਧੀ—ਇਹ ਵਧੀਆ ਤਰੀਕੇ ਨਾਲ ਪਹੁੰਚਯੋਗ ਬਣ ਗਿਆ। ਇੱਕ ਫਰੰਟਐਂਡ-重 ਰੁਝਾਨ ਵਾਲਾ ਡਿਵੈਲਪਰ ਸਰਵਰ ਕੋਡ ਪੜ੍ਹ ਸਕਦਾ ਸੀ ਬਿਨਾਂ ਨਵੀਂ ਪੂਰੀ ਇਕੋਸਿਸਟਮ ਸਿਖਣ ਦੇ, ਅਤੇ ਛੋਟੀ ਟੀਮਾਂ ਘੱਟ ਹੈਂਡੌਫ਼ ਨਾਲ ਪ੍ਰੋਟੋਟਾਈਪ ਅਤੇ ਅੰਦਰੂਨੀ ਟੂਲ ਜਲਦੀ ਰੀਲੀਜ਼ ਕਰ ਸਕਦੀਆਂ ਸਨ।
Node ਦਾ ਇਵੈਂਟ‑ਡ੍ਰਾਈਵਨ ਮਾਡਲ ਅਤੇ npm ਡਿਪੈਂਡੇਂਸੀ ਇੱਕ ਤਿੱਛੇ ਇਤਰਾਜ ਨੂੰ ਉਤਸ਼ਾਹਤ ਕਰਦੇ ਸਨ। ਤੁਸੀਂ ਇੱਕ ਛੋਟੇ ਸਰਵਰ ਨਾਲ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ, ਇੱਕ-ਇਕ ਡੀਪੈਂਡੈਂਸੀ ਜੋੜਦਿਆਂ ਜਾ ਸਕਦੇ ਹੋ, ਅਤੇ ਜਦੋਂ ਅਸਲੀ ਲੋੜ ਆਏ ਤਾਂ ਫੀਚਰ ਵਧਾ ਸਕਦੇ ਹੋ।
ਪਰ ਸ਼ੁਰੂਆਤੀ Node ਨੇ ਇੱਕ ਖਲੀਆਂ ਵੀ ਦਰਸਾਈ: ਬਿਲਟ-ਇਨ HTTP ਮੋਡੀਊਲ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੀ, ਪਰ ਬਹੁਤ ਨੀਵਾਂ-ਪੱਧਰ ਦਾ। ਰਾਊਟਿੰਗ, ਬਾਡੀ ਪਾਰਸਿੰਗ, ਕੁਕੀਜ਼, ਸੈਸ਼ਨ ਅਤੇ ਐਰਰ ਜਵਾਬ ਸੰਭਾਲਣ ਦਾ ਹਰ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਦੁਹਰਾਅ ਲਗਦਾ ਸੀ।
ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇੱਕ ਭਾਰੀ “ਹਰ ਚੀਜ਼ ਸ਼ਾਮਲ” ਫਰੇਮਵਰਕ ਨਹੀਂ ਚਾਹੀਦਾ ਸੀ। ਉਹ ਇੱਕ ਅਸਾਨ ਤਰੀਕੇ ਦੀ ਤਲਾਸ਼ ਵਿੱਚ ਸਨ, ਜੋ ਕਿ:
ਆਇਡੀਅਲ ਟੂਲ ਕਾਫੀ ਛੋਟਾ ਸੀ ਕਿ ਇੱਕ ਦੁਪਹਿਰ ਵਿੱਚ ਸਿੱਖਿਆ ਜਾ ਸਕੇ, ਪਰ ਇੰਨਾ ਸੰਰਚਿਤ ਕਿ ਹਰ ਐਪ ਇੱਕ ਵਿਲੱਖਣ ਹੈਂਡਲਰਾਂ ਦਾ ਝੁੰਡ ਨਾ ਬਣ ਜਾਵੇ।
Express ਓਸ ਸਮੇਂ ਠੀਕ ਵੇਲੇ ਆਇਆ: ਇੱਕ ਛੋਟੀ ਕੋਰ ਅਤੇ ਸਪੱਸ਼ਟ ਰਿਵਾਜਾਂ ਨਾਲ। ਇਸ ਨੇ ਟੀਮਾਂ ਨੂੰ ਰਾਊਟਾਂ ਅਤੇ middleware ਰੱਖਣ ਲਈ ਇੱਕ ਸਿੱਧਾ ਥਾਂ ਦਿੱਤੀ, ਬਿਨਾਂ ਪਹਿਲੋਂ ਹੀ ਇੱਕ ਜਟਿਲ ਆਰਕੀਟੈਕਚਰ ਲਾਘੂ ਕਰਨ ਦੇ।
ਵੱਧ ਮਹੱਤਵਪੂਰਨ ਗੱਲ, Express ਹਰ ਚੀਜ਼ ਸੈਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ। ਮਿਨੀਮਲ ਰਹਿ ਕੇ, ਇਸਨੇ ਕਮਿਊਨਿਟੀ ਨੂੰ “ਵਿਕਲਪਿਕ ਹਿੱਸਿਆਂ” ਨੂੰ add-ons ਵਜੋਂ ਬਣਾਉਣ ਦੀ ਜਗ੍ਹਾ ਛੱਡੀ—authentication strategies, validation helpers, logging, templating, ਅਤੇ ਬਾਅਦ ਵਿੱਚ API-ਕੇਂਦ੍ਰਿਤ ਟੂਲਿੰਗ।
ਇਹ ਡਿਜ਼ਾਈਨ ਚੋਣ Express ਨੂੰ ਅਨੇਕ Node ਬੈਕਐਂਡ ਲਈ ਆਮ ਸ਼ੁਰੂਆਤ ਬਣਾਉਂਦੀ ਹੈ, ਛੋਟੇ ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਲੈ ਕੇ ਪ੍ਰੋਡਕਸ਼ਨ ਸਰਵਿਸਾਂ ਤੱਕ।
Express Node.js ਲਈ ਇੱਕ ਹਲਕਾ ਵੈੱਬ ਫਰੇਮਵਰਕ ਹੈ। ਇਸਨੂੰ ਇਕ ਪਤਲੀ ਪਰਤ ਵਜੋਂ ਸੋਚੋ ਜੋ ਤੁਹਾਨੂੰ HTTP ਬੇਨਤੀਆਂ (ਜਿਵੇਂ GET /products) ਲੈਣ ਅਤੇ ਜਵਾਬ ਭੇਜਣ (JSON, HTML, ਜਾਂ redirect) ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਡੇ, ਰਾਇ-ਭਰਪੂਰ ਢਾਂਚੇ ਵਿੱਚ ਫਸਾਏ।
ਇਹ ਤੁਹਾਡੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ। ਇਸਦੀ ਥਾਂ, ਇਹ ਕੁਝ ਮੁੱਖ ਬਿਲਡਿੰਗ ਬਲਾਕ ਦਿੰਦਾ ਹੈ—app object, routing, ਅਤੇ middleware—ਤਾਂ ਜੋ ਤੁਸੀਂ ਬਿਲਕੁਲ ਆਪਣੀ ਲੋੜ ਅਨੁਸਾਰ ਸਰਵਰ ਜੋੜ ਸਕੋ।
Express ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਰਾਊਟਿੰਗ ਹੈ: HTTP ਮੈਥਡ ਅਤੇ URL ਪਾਥ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਮੈਪ ਕਰਨਾ।
ਹੈਂਡਲਰ ਉਹ ਕੋਡ ਹੁੰਦਾ ਹੈ ਜੋ ਜਦੋਂ ਕੋਈ ਬੇਨਤੀ ਮਿਲਦੀ ਹੈ ਤਾਂ ਚਲਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ GET /health ਮੰਗ ਕੀਤੀ ਜਾਵੇ, ਇੱਕ ਫੰਕਸ਼ਨ ਚਲਾਓ ਜੋ “ok” ਵਾਪਸ ਕਰੇ। ਜਦੋਂ POST /login ਆਏ, ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਚਲਾਓ ਜੋ ਕ੍ਰੈਡੇਨਸ਼ਲ ਜਾਂਚ ਕਰੇ ਅਤੇ ਕੁਕੀ ਸੈੱਟ ਕਰੇ।
ਇਹ "ਰਾਊਟਾਂ ਨੂੰ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਮੈਪ ਕਰੋ" ਵਾਲਾ ਤਰੀਕਾ ਸੋਚਣ ਵਿੱਚ ਆਸਾਨ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਆਪਣੇ ਸਰਵਰ ਨੂੰ ਵਰਗੀ-ਸੂਚੀ ਵਾਂਗ ਪੜ੍ਹ ਸਕਦੇ ਹੋ: ਇੱਥੇ endpoints ਹਨ, ਅਤੇ ਹਰ ਇੱਕ ਕੀ ਕਰਦਾ ਹੈ।
ਜਦੋਂ ਇੱਕ ਬੇਨਤੀ ਆਉਂਦੀ ਹੈ, Express ਤੁਹਾਨੂੰ ਦੋ ਮੁੱਖ ਆਬਜੈਕਟ ਦਿੰਦਾ ਹੈ:
Request: ਕਲਾਇੰਟ ਨੇ ਕੀ ਭੇਜਿਆ (URL, headers, body, cookies)Response: ਤੁਸੀਂ ਕੀ ਵਾਪਸ ਭੇਜੋਗੇ (status code, headers, body)ਤੁਹਾਡਾ ਕੰਮ ਬੇਨਤੀ ਨੂੰ ਵੇਖਣਾ, ਫੈਸਲਾ ਕਰਨਾ ਕਿ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਜਵਾਬ ਭੇਜ ਕੇ ਮੁਕੰਮਲ ਕਰਨਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਜਵਾਬ ਨਹੀਂ ਭੇਜਦੇ, ਤਾਂ ਕਲਾਇੰਟ ਉਡੀਕ ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ।
ਇਸ ਦਰਮਿਆਨ, Express middleware ਦੀ ਇੱਕ ਲੜੀ ਚਲਾ ਸਕਦਾ ਹੈ: logging, JSON body parsing, authentication ਜਾਂਚ, error handling ਅਤੇ ਹੋਰ। ਹਰ ਕਦਮ ਕੁਝ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਅਗਲੇ ਨੂੰ ਕਨਟਰੋਲ ਸੌਂਪਦਾ ਹੈ।
Express ਲੋਕਪ੍ਰਿਯ ਹੋਇਆ ਕਿਉਂਕਿ ਇਸਦੀ ਸਤਹ ਛੋਟੀ ਹੈ: ਕੁਝ ਹੀ ਖਿਆਲ ਤੁਹਾਨੂੰ ਇੱਕ ਕੰਮ ਕਰਦੇ API ਤੱਕ ਲੈ ਜਾਂਦੇ ਹਨ। ਰਿਵਾਜ ਸਪਸ਼ਟ ਹਨ (routes, middleware, req/res), ਅਤੇ ਤੁਸੀਂ ਸਧਾਰਨ ਤਰੀਕੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ—ਇੱਕ ਫਾਈਲ, ਕੁਝ ਰਾਊਟਸ—ਫਿਰ ਜਦੋਂ ਪ੍ਰੋਜੈਕਟ ਵਧੇ ਤਾਂ ਫੋਲਡਰ ਤੇ ਮੋਡੀਊਲ ਬਣਾਕੇ ਵੰਡ ਸਕਦੇ ਹੋ।
ਇਹ "ਛੋਟੇ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ, ਜ਼ਰੂਰਤ ਅਨੁਸਾਰ ਵਧੋ" ਵਾਲਾ ਅਨੁਭਵ Express ਨੂੰ ਬਹੁਤ ਸਾਰਿਆਂ ਲਈ ਡਿਫੌਲਟ ਚੋਣ ਬਣਾਉਂਦਾ ਹੈ।
Express ਅਤੇ Koa ਅਕਸਰ "ਮਿਨੀਮਲ" ਆਖੇ ਜਾਂਦੇ ਹਨ, ਪਰ ਉਹਨਾਂ ਦੀ ਅਸਲ ਖਾਸੀਅਤ ਸੋਚਦਾ ਤਰੀਕਾ ਹੈ: middleware। ਮਿਡਲਵੇਅਰ ਇਕ ਵੈੱਬ ਬੇਨਤੀ ਨੂੰ ਛੋਟੇ ਕਦਮਾਂ ਦੀ ਸਿਰੀਜ਼ ਵਜੋਂ ਮੰਨਦਾ ਹੈ ਜੋ ਬਦਲਾਅ, ਸੰਦਰਭ ਜੋੜਣਾ ਜਾਂ ਇਸਨੂੰ ਰੱਦ ਕਰ ਸਕਦੇ ਹਨ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਜਵਾਬ ਭੇਜਿਆ ਜਾਵੇ।
ਇੱਕ ਵੱਡੇ ਹੈਂਡਲਰ ਦੇ ਬਦਲੇ, ਤੁਸੀਂ focused functions ਦੀ ਲੜੀ ਬਣਾਉਂਦੇ ਹੋ। ਹਰ ਇੱਕ ਦਾ ਇੱਕ ਹੀ ਕੰਮ ਹੁੰਦਾ—ਸੰਦਰਭ ਜੋੜੋ, ਕੁਝ ਵੈਰੀਫਾਈ ਕਰੋ, ਏਕ ਅਸਪਸ਼ਟਤਾ ਸਾਂਭੋ—ਫਿਰ ਅਗਲੇ ਨੂੰ ਕਨਟਰੋਲ ਸੌਂਪੋ। ਐਪ ਇੱਕ ਪਾਈਪਲਾਈਨ ਬਣ ਜਾਂਦਾ ਹੈ: ਬੇਨਤੀ ਅੰਦਰ, ਜਵਾਬ ਬਾਹਰ।
ਅਕਸਰ ਪ੍ਰੋਡਕਸ਼ਨ ਬੈਕਐਂਡ ਇੱਕ ਜਾਣੀ-ਪਹਚਾਣੀ ਸੈੱਟ ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ:
ਇਸ ਕਰਕੇ "ਮਿਨੀਮਲ" ਫਰੇਮਵਰਕ ਵੀ ਗੰਭੀਰ APIs ਚਲਾ ਸਕਦੇ ਹਨ: ਤੁਸੀਂ केवल ਉਹ ਹੀ ਵਿਹਾਰ ਜੋੜਦੇ ਹੋ ਜੋ ਲੋੜੀਦਾ ਹੈ, ਓਹਦੀ ਲੜੀ ਅਨੁਕ੍ਰਮ ਵਿੱਚ।
Middleware ਮਿਲਾਪ ਅਤੇ ਮੁਕਾਬਲਾ ਕਰਨ ਦੀ ਹिम्मਤ ਦਿੰਦਾ ਹੈ। ਜਦੋਂ ਲੋੜ ਬਦਲੇ—ਨਵਾਂ auth strategy, ਸਖਤ validation, ਵੱਖਰਾ logging—ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਕਦਮ ਬਦਲ ਸਕਦੇ ਹੋ, ਪੂਰੇ ਐਪ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ।
ਇਹ ਕੋਡ ਸਟਾਈਲ ਅਤੇ ਫੋਲਡਰ ਸੰਰਚਨਾ ਨੂੰ ਵੀ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਟੀਮਾਂ ਅਕਸਰ ਲੇਅਰਾਂ (ਉਦਾਹਰਨ ਲਈ /middleware, /routes, /controllers) ਜਾਂ ਫੀਚਰਾਂ ਅਨੁਸਾਰ ਅਯੋਜਿਤ ਕਰਦੀਆਂ ਹਨ (ਪ੍ਰਤੀ ਫੀਚਰ ਰਾਹ + middleware)। ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ, middleware ਦੀ ਹੱਦ ਤੁਹਾਨੂੰ ਛੋਟੇ, ਟੈਸਟਯੋਗ ਹਿੱਸਿਆਂ ਵੱਲ ਧੱਕਦੀ ਹੈ ਜੋ ਨਵੇਂ ਡਿਵੈਲਪਰ ਲਈ ਸਿੱਖਣਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ।
Koa TJ Holowaychuk ਦੀ ਦੂਜੀ ਕੋਸ਼ਿਸ਼ ਹੈ ਇੱਕ ਮਿਨੀਮਲ Node.js ਵੈੱਬ ਫਰੇਮਵਰਕ ਲਈ। ਇਹ Express ਦੇ ਬਾਅਦ ਬਣਾਇਆ ਗਿਆ ਸੀ ਜਦੋਂ ਇਹ ਸਾਬਤ ਹੋ ਗਿਆ ਕਿ "ਛੋਟਾ ਕੋਰ + middleware" ਮਾਡਲ ਗੰਭੀਰ ਪ੍ਰੋਡਕਸ਼ਨ ਐਪਸ ਚਲਾ ਸਕਦਾ ਹੈ—ਪਰ ਉਸ ਦੇ ਸ਼ੁਰੂਆਤੀ ਡਿਜ਼ਾਈਨ ਸੀਮਾਵਾਂ ਵੀ ਸਾਹਮਣੇ ਆਉਣ ਲੱਗੀਆਂ।
Express ਉਹ ਦੌਰ ਦੇ callback-heavy APIs ਵਿਚ ਵਧਿਆ। Koa ਦਾ ਮਕਸਦ ਸੀਕੋਰੇ ਕੋਰ ਨੂੰ ਹੋਰ ਵੀ ਛੋਟਾ ਕਰਨਾ, ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਹੋਰ ਫੈਸਲੇ ਕਰਨ ਦੇ ਲਈ ਛੱਡਣਾ। ਨਤੀਜਾ ਇੱਕ ਐਸਾ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਇੱਕ ਬੰਡਲਡ ਟੂਲਕਿਟ ਵਾਂਗ ਨਹੀਂ, ਬਲਕਿ ਇੱਕ ਸਾਫ ਨੀਵ ਵਾਂਗ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।
Koa ਜਾਣ-ਬੂਝ ਕੇ ਬਹੁਤ ਸਾਰੀਆਂ "ਸਟੈਂਡਰਡ" ਫੀਚਰ (ਰਾਊਟਿੰਗ, ਬਾਡੀ ਪਾਰਸਿੰਗ, ਟੈਂਪਲੇਟਿੰਗ) ਨਹੀਂ ਭੇਜਦਾ। ਇਹ ਗਲਤੀ ਨਹੀਂ—ਇਹ ਹਰ ਪ੍ਰੋਜੈਕਟ ਲਈ ਸਪਸ਼ਟ ਬਿਲਡਿੰਗ ਬਲਾਕ ਚੁਣਨ ਵੱਲ ਇਕ ਨੁਕਤਾ ਹੈ।
Koa ਦੇ ਸਭ ਤੋਂ ਕਾਰਗਰ ਸੁਧਾਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਹ ਹੈ ਕਿ ਇਹ ਰਿਕਵੈਸਟ ਫਲੋ ਨੂੰ ਕਿਵੇਂ ਮਾਡਲ ਕਰਦਾ ਹੈ। ਧਾਰਣਾ ਦੇ ਤੌਰ 'ਤੇ, callback ਨੂੰ "ਪਾਸ ਕੰਟਰੋਲ" ਕਰਨ ਦੀ ਥਾਂ, Koa middleware ਨੂੰ ਪ੍ਰੇਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਉਹ ਰੋਕੇ ਅਤੇ ਫਿਰ ਮੁੜ ਸ਼ੁਰੂ ਕਰ ਸਕੇ:
await ਕਰੋਇਸ ਨਾਲ ਸੋਚਣਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿ "ਇਕ ਹੈਂਡਲਰ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਕੀ ਹੁੰਦਾ ਹੈ", ਬਿਨਾਂ ਮਨ-ਵਿਗਿਆਨਕ ਘੁੰਮਾਫਿਰੇ ਦੇ।
Koa ਉਸ ਫਿਲਾਸਫੀ ਨੂੰ ਰਖਦਾ ਹੈ ਜਿਸਨੇ Express ਨੂੰ ਸਿਰਫ਼ ਛੋਟਾ ਬਣਾ ਦਿੱਤਾ:
ਸੋ Koa "Express ਪਰ ਨਵਾਂ" ਨਹੀਂ—ਇਹ Express ਦੇ ਮਿਨੀਮਲ ਵਿਚਾਰ ਨੂੰ ਅੱਗੇ ਧੱਕਦਾ ਹੈ: ਇੱਕ ਹੋਰ ਵੀ ਸਲਿਮ ਕੋਰ ਅਤੇ ਬੇਨਤੀ ਲਾਈਫਸਾਈਕਲ 'ਤੇ ਹੋਰ ਸਪਸ਼ਟ ਨਿਯੰਤਰਣ।
Express ਅਤੇ Koa ਦਾ ਡੀਐਨਏ ਇੱਕੋ ਜਿਹਾ ਹੈ, ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਕੁਝ ਗੰਭੀਰ ਬਣਾਉਂਦੇ ਹੋ ਤਾਂ ਇਹ ਵੱਖਰਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ। ਮੁੱਖ ਫਰਕ ਇਹ ਨਹੀਂ ਕਿ ਕੌਣ ਨਵਾਂ ਹੈ—ਇਹ ਹੈ ਕਿ ਹਰ ਇੱਕ ਤੁਹਾਨੂੰ ਬਾਹਰੋਂ ਕਿੰਨੀ ਸੰਰਚਨਾ ਦਿੰਦਾ ਹੈ।
Express ਸਿਖਣ ਵਿੱਚ ਆਸਾਨ ਹੈ ਕਿਉਂਕਿ ਇਹਦਾ ਮਨੋ-ਮਾਡਲ ਸਧਾਰਣ ਹੈ: ਰਾਊਟ ਬਣਾਓ, middleware ਲਗਾਓ, ਜਵਾਬ ਭੇਜੋ। ਜ਼ਿਆਦਾਤਰ ਟਿਊਟੋਰਿਅਲ ਇੱਕ ਜਿਹੇ ਦਿੱਸਦੇ ਹਨ, ਇਸ ਲਈ ਨਵੇਂ ਮੈਂਬਰ ਤੇਜ਼ੀ ਨਾਲ ਉਤਪਾਦਕ ਹੋ ਜਾਂਦੇ ਹਨ।
Koa ਕੋਰ ਵਿੱਚ ਹੋਰ ਸਧਾਰਤ ਹੈ, ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ ਤੁਸੀਂ ਹੋਰ ਚੀਜ਼ਾਂ ਖੁਦ ਇਕੱਠੀਆਂ ਕਰੋਗੇ। async/await-ਪਹਿਨ ਵਾਲਾ ਤਰੀਕਾ ਸੁਧਾਰਦਾਇਕ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਸ਼ੁਰੂ ਵਿੱਚ ਤੁਹਾਨੂੰ ਹੋਰ ਫੈਸਲੇ ਕਰਨੇ ਪੈਣਗੇ (routing, request validation, error handling ਅਦਿ) ਤਾਂ ਜੋ ਐਪ "ਮੁਕੰਮਲ" ਲੱਗੇ।
Express ਦੀ ਕਮਿਊਨਿਟੀ ਵੱਡੀ ਹੈ, zyada copy‑paste ਕਰਨ ਯੋਗ ਉਦਾਹਰਣ ਹਨ, ਅਤੇ ਕਈ ਲਾਇਬ੍ਰੇਰੀਜ਼ Express ਪਰੰਪਰਾਵਾਂ ਮੰਨ ਕੇ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ।
Koa ਦਾ ਇਕੋਸਿਸਟਮ ਸਿਹਤਮੰਦ ਹੈ, ਪਰ ਇਹ ਉਮੀਦ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਮੋਡੀਊਲ ਚੁਣੋਂਗੇ। ਇਹ ਉਹਨਾਂ ਲਈ ਚੰਗਾ ਹੈ ਜਿਹੜੇ ਕੰਟਰੋਲ ਚਾਹੁੰਦੇ ਹਨ, ਪਰ ਉਹਨਾਂ ਟੀਮਾਂ ਲਈ ਜੋ ਇੱਕ ਸਪਸ਼ਟ ਸਟੈਕ ਚਾਹੁੰਦੀਆਂ ਹਨ, ਕਈ ਵਾਰੀ ਧੀਰਜ ਘਟ ਸਕਦੀ ਹੈ।
Express ਫਿੱਟ:
Koa ਫਿੱਟ:
ਜਦੋਂ ਪ੍ਰਯੋਗਕਤਾ ਜਿੱਤਦੀ ਹੋਵੇ ਤਾਂ Express ਚੁਣੋ: ਤੁਸੀ ਸਭ ਤੋਂ ਛੋਟਾ ਰਸਤਾ ਇੱਕ ਕੰਮ ਕਰਦੀਆਂ ਸਰਵਿਸ ਲਈ, ਪੇਸ਼ਗੋਈਯੋਗ ਨਮੂਨੇ, ਅਤੇ tooling ਬਾਰੇ ਘੱਟ ਵਾਦ-ਵਿਵਾਦ ਚਾਹੁੰਦੇ ਹੋ।
ਜਦੋਂ ਤੁਸੀਂ "ਆਪਣਾ ਫਰੇਮਵਰਕ ਡਿਜ਼ਾਈਨ" ਕਰਨ ਲਈ ਤਿਆਰ ਹੋ ਤਾਂ Koa ਚੁਣੋ: ਤੁਸੀਂ ਇੱਕ ਸਾਫ ਕੋਰ, middleware ਸਟੈਕ 'ਤੇ ਭਰੋਸਾ ਅਤੇ ਪਰੰਪਰਾਵਾਂ ਦੇ ਪ੍ਰਭਾਵ ਤੋਂ ਮੁਕਤ ਰਹਿਣਾ ਚਾਹੁੰਦੇ ਹੋ।
Express ਅਤੇ Koa ਜਾਣ-ਬੁਝ ਕੇ ਛੋਟੇ ਰਹਿੰਦੇ ਹਨ: ਇਹ HTTP ਬੇਨਤੀ/ਜਵਾਬ ਲਾਈਫਸਾਈਕਲ, ਰਾਊਟਿੰਗ ਆਦਿ ਸੰਭਾਲਦੇ ਹਨ ਅਤੇ middleware ਪਾਈਪਲਾਈਨ ਨੂੰ ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ। ਹਰ ਚੀਜ਼ ਨਹੀਂ ਬੰਡਲ ਕਰਨ ਨਾਲ, ਇਹ ਕਮਿਊਨਿਟੀ ਲਈ ਬਾਕੀ ਬਣਾਉਣ ਦੀ ਜਗ੍ਹਾ ਛੱਡਦੇ ਹਨ।
ਇੱਕ ਮਿਨੀਮਲ ਫਰੇਮਵਰਕ ਇੱਕ ਸਥਿਰ "ਜੋੜ ਸਥਾਨ" ਬਣ ਜਾਂਦਾ ਹੈ। ਜਿਵੇਂ ਹੀ ਕਈ ਟੀਮ ਇੱਕੋ ਨਿਮਨ-ਸਿਧਾਂਤਾਂ (request objects, middleware ਸਿਗਨੇਚਰ, error convention) 'ਤੇ ਨਿਰਭਰ ਕਰਨ ਲੱਗਦੀਆਂ ਹਨ, add-ons ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ ਜੋ ਸਾਫ਼ ਤਰ੍ਹਾਂ ਨਾਲ ਪਲੱਗ ਹੋ ਜਾਂਦੇ ਹਨ।
ਇਸ ਲਈ Express ਅਤੇ Koa npm ਇਕੋਸਿਸਟਮ ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਬੈਠੇ ਹਨ—ਭਾਵੇਂ ਫਰੇਮਵਰਕ ਆਪਣੇ ਆਪ ਵਿੱਚ ਨਿੱਘੇ ਦਿਸੇ ਹੋਣ।
ਆਮ add-on ਸ਼੍ਰੇਣੀਆਂ:
ਇਹ "ਆਪਣੇ-ਆਪਣੇ ਬਿਲਡਿੰਗ-ਬਲਾਕ ਲਿਆਓ" ਮਾਡਲ ਤੁਹਾਨੂੰ ਪ੍ਰੋਡਕਟ ਅਨੁਸਾਰ ਬੈਕਐਂਡ ਟੇਲਰ ਕਰਨ ਦੀ ਆਜ਼ਾਦੀ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਛੋਟਾ ਅੰਦਰੂਨੀ admin API ਨੂੰ ਬਸ logging ਅਤੇ auth ਚਾਹੀਦਾ ਹੋ ਸਕਦਾ ਹੈ, ਜਦਕਿ ਇੱਕ ਪਬਲਿਕ API ਨੂੰ validation, rate limiting, caching, ਅਤੇ observability ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ।
ਮਿਨੀਮਲ ਕੋਰ ਤੁਹਾਨੂੰ ਸਿਰਫ ਜੋ ਲੋੜ ਹੈ ਉਹੀ ਪਹਿਲਾ ਲਾਉਣ ਅਤੇ ਜਦ ਲੋੜ ਹੋਵੇ ਇਕੋਸਿਸਟਮ ਦੇ ਹਿੱਸੇ ਬਦਲਣ ਦੀ ਆਸਾਨੀ ਦਿੰਦਾ ਹੈ।
ਇਹੀ ਆਜ਼ਾਦੀ ਖਤਰਾ ਵੀ ਬਣਦੀ ਹੈ:
ਅਸਲ ਵਿੱਚ, Express/Koa ਇਕੋਸਿਸਟਮ ਉਹਨਾਂ ਟੀਮਾਂ ਨੂੰ ਇਨਾਮ ਦਿੰਦਾ ਹੈ ਜੋ ਇੱਕ "standard stack" ਕੁਰੇਟ ਕਰਦੀਆਂ ਹਨ, ਵਰਜ਼ਨ ਪਿਨ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ dependencies ਦੀ ਸਮੀਖਿਆ ਕਰਦੀਆਂ ਹਨ—ਕਿਉਂਕਿ ਫਰੇਮਵਰਕ ਇਹ ਗਵਰਨੈਂਸ ਤੁਹਾਡੇ ਲਈ ਨਹੀਂ ਕਰਦਾ।
Express ਅਤੇ Koa ਜਾਣ-ਬੁਝ ਕੇ ਛੋਟੇ ਰਹਿੰਦੇ ਹਨ: ਇਹ route ਕਰਦੇ ਹਨ, ਹੈਂਡਲਰਾਂ ਨੂੰ ਢਾਂਚਾ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ, ਅਤੇ middleware ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ। ਇਹ ਇੱਕ ਮਜ਼ਬੂਤੀ ਹੈ—ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ ਇਹ ਉਹ "ਸੇਫ defaults" ਆਪ-ਆਪਣੇ ਤੁਹਾਡੇ ਲਈ ਨਹੀਂ ਦਿੰਦੇ ਜੋ ਲੋਕ ਕਈ ਵਾਰੀ assume ਕਰ ਲੈਂਦੇ ਹਨ।
ਇੱਕ ਮਿਨੀਮਲ ਬੈਕਐਂਡ ਨੂੰ ਸੁਚੇਤ ਸੁਰੱਖਿਆ ਚੈਕਲਿਸਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਘੱਟੋ-ਘੱਟ:
ਰੁਕਾਵਟਾਂ ਅਟੱਲ ਹਨ; ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਇਹ ਹੈ ਕਿ ਉਹ ਕਿੰਨੀ ਲਗਾਤਾਰ ਅਤੇ ਇਕਸਾਰ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
Express ਵਿੱਚ ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ error handling ਕੇਂਦਰੀક੍ਰਿਤ middleware ਨਾਲ ਕਰਦੇ ਹੋ (ਉਹ ਅਗਲੇ ਸੀਨੇ ਦੇ 4 arguments ਵਾਲਾ)। Koa ਵਿੱਚ ਆਮ ਤਰੀਕਾ ਹੈ ਕਿ middleware ਸਟੈਕ ਦੇ ਸਿਖਰ ਨੂੰ try/catch ਨਾਲ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ।
ਚੰਗੇ ਨਮੂਨੇ:
{ code, message, details }) ਤਾਂ ਕਿ ਕਲਾਇੰਟ ਨੂੰ ਭਟਕਾਉਣ ਦੀ ਲੋੜ ਨਾ ਪਵੇ।ਮਿਨੀਮਲ ਫਰੇਮਵਰਕ ਤੁਹਾਡੇ ਲਈ ਓਪਰੇਸ਼ਨਲ ਜ਼ਰੂਰੀਆਂ ਸੈਟਅਪ ਨਹੀਂ ਕਰਦੇ:
/health) ਜੋ ਡੈਟਾ ਬੇਸ ਵਰਗੀਆਂ ਆਵਸ਼ਯਕ dependencies ਦੀ ਜਾਂਚ ਕਰਨ।ਬਹੁਤ ਸਾਰੀਆਂ ਸੁਰੱਖਿਆ ਸਮੱਸਿਆਵਾਂ ਪੈਕੇਜਜ਼ ਰਾਹੀਂ ਆਉਂਦੀਆਂ ਹਨ, ਨਾ ਕਿ ਤੁਹਾਡੇ ਰਾਊਟਰ ਰਾਹੀਂ।
ਚੰਗੀ ਰੀਤ ਦੀਆਂ ਚੀਜ਼ਾਂ ਕਰੋ: ਵੇਲ-ਮੈਂਟੇਨਡ ਮੋਡਿਊਲ ਚੁਣੋ, ਹਾਲੀਆ ਰਿਲੀਜ਼ਾਂ, ਸਾਫ ਮੁਲਕਾ-ਕੌਪ, ਅਤੇ ਵਧੀਆ ਡੌਕ। ਆਪਣੀ dependency ਲਿਸਟ ਛੋਟੀ ਰੱਖੋ, "ਇੱਕ-ਲਾਈਨ হੇਲਪਰ" ਪੈਕੇਜ ਤੋਂ ਬਚੋ, ਅਤੇ ਨਿਯਮਤ ਤੌਰ 'ਤੇ vulnerabilities ਲਈ ਆਡੀਟ ਕਰੋ।
ਜਦੋਂ ਤੁਸੀਂ middleware ਜੋੜੋ, ਇਸਨੂੰ production ਕੋਡ ਵਾਂਗ ਸੰਭਾਲੋ: defaults ਦੀ ਸਮੀਖਿਆ ਕਰੋ, explicit configuration ਕਰੋ, ਅਤੇ ਅਪਡੇਟ ਕਰਦੇ ਰਹੋ।
Express ਅਤੇ Koa ਸੜਕ ਤੇ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ, ਪਰ ਉਹ ਚੰਗੀਆਂ ਸੀਮਾਵਾਂ ਲਗਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਮਜ਼ਬੂਰ ਨਹੀਂ ਕਰਦੇ। "Maintainable" ਇਸ ਗੱਲ ਬਾਰੇ ਹੈ ਕਿ ਅਗਲਾ ਬਦਲਾਅ ਕੀਤੇ ਜਾ ਸਕਣ ਵੱਡੀ ਆਸਾਨੀ ਨਾਲ—ਨਾ ਕਿ صرف ਲਾਈਨਾਂ ਘੱਟ ਹੋਣ।
ਇੱਕ maintainable ਬੈਕਐਂਡ ਹੋਣਾ ਚਾਹੀਦਾ:
ਜੇ ਤੁਸੀਂ ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ "ਇਹ ਕੋਡ ਕਿੱਥੇ ਰਹੇਗਾ?" ਦਾ ਵਿਸ਼ਵਾਸ ਨਾਲ ਜਵਾਬ ਨਹੀਂ ਦੇ ਸਕਦੇ, ਤਾਂ ਪ੍ਰੋਜੈਕਟ ਪਹਿਲਾਂ ਹੀ ਘੁੱਟ ਰਿਹਾ ਹੈ।
Middleware ਤਾਕਤਵਰ ਹੈ, ਪਰ ਲੰਬੀਆਂ ਲੜੀਆਂ "action at a distance" ਬਣ ਸਕਦੀਆਂ ਹਨ, ਜਿੱਥੇ ਕੋਈ header ਜਾਂ error response ਉਸ ਰਾਊਟ ਤੋਂ ਕਾਫੀ ਦੂਰ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੋਵੇ।
ਕੁਝ ਆਦਤਾਂ ਗੁੰਝਲ ਤੋਂ ਬਚਾਉਂਦੀਆਂ ਹਨ:
Koa ਵਿੱਚ await next() ਦੀ ਤਾਂਬਦਾਰੀ 'ਤੇ ਵਿਸ਼ੇਸ਼ ਧਿਆਨ ਰੱਖੋ; Express ਵਿੱਚ next(err) ਜਾਂ response ਵਾਪਸ ਕਰਨ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਸਖ਼ਤੀ ਨਾਲ ਵਿਵਹਾਰ ਕਰੋ।
ਇੱਕ ਸਮਰੱਥ ਸਤਰ ਜੋ ਵਧਦੀ ਹੈ:
/web HTTP ਮਾਮਲੇ (routes, controllers, request parsing)/domain ਕਾਰੋਬਾਰੀ ਲਾਜਿਕ (services/use-cases)/data persistence (repositories, queries)ਉਹਨਾਂ ਲੇਅਰਾਂ ਨੂੰ ਫੀਚਰ ਅਨੁਸਾਰ ਗਰੁੱਪ ਕਰੋ (ਉਦਾਹਰਣ ਲਈ billing, users) ਤਾਂ ਕਿ "ਇੱਕ billing ਨਿਯਮ ਜੋੜੋ" ਦਾ ਮਤਲਬ ਬਾਹਰ-ਭਟਕਣਾ ਨਾ ਹੋਵੇ।
ਮੁੱਖ ਹੱਦਬੰਦੀ: web ਕੋਡ HTTP → domain inputs ਨੂੰ ਤਬਦੀਲ ਕਰਦਾ ਹੈ, ਅਤੇ domain ਨਤੀਜੇ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ web ਲੇਅਰ HTTP ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ।
ਇਹ ਵੰਡ ਟੈਸਟ ਫਾਸਟ ਰੱਖਦੀ ਹੈ ਅਤੇ ਹਕੀਕਤੀ ਵਾਇਰਿੰਗ ਮੁੱਦਿਆਂ ਨੂੰ ਫੜਦੀ ਹੈ—ਬਿਲਕੁਲ ਉਹ ਜੋ ਮਿਨੀਮਲ ਫਰੇਮਵਰਕ ਤੁਹਾਡੇ ਉੱਤੇ ਛੱਡਦੇ ਹਨ।
Express ਅਤੇ Koa 2025 ਵਿੱਚ ਅਜੇ ਵੀ ਮਾਨੇ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ Node.js ਫਰੇਮਵਰਕ ਅਧਾਰ-ਸਪੈਕਟ੍ਰਮ ਦੇ "ਛੋਟਾ ਕੋਰ" ਪਾਸੇ ਨੁਮਾਇੰਦਗੀ ਕਰਦੇ ਹਨ। ਇਹ ਤੁਹਾਡੇ ਐਪਲੇਕੇਸ਼ਨ ਦਾ ਹਰ ਪੱਖ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦੇ—ਕੇਵਲ HTTP ਬੇਨਤੀ/ਜਵਾਬ ਲੇਅਰ—ਇਸ ਲਈ ਇਹਨਾਂ ਨੂੰ ਅਕਸਰ ਸਿੱਧਾ APIs ਲਈ ਜਾਂ ਤੁਹਾਡੇ ਆਪਣੇ ਮੋਡੀਊਲਾਂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਇੱਕ ਪਤਲੀ ਖੋਲ ਰੂਪ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ Express ਵਰਗੀ ਚੀਜ਼ ਚਾਹੁੰਦੇ ਹੋ ਪਰ ਤੇਜ਼ੀ ਅਤੇ ਥੋੜ੍ਹੀ ਹੋਰ ਆਧੁਨਿਕ ਸੁਵਿਧਾ, ਤਾਂ Fastify ਇੱਕ ਆਮ ਅਗਲਾ ਕਦਮ ਹੈ। ਇਹ "ਮਿਨੀਮਲ ਫਰੇਮਵਰਕ" ਸਪਿਰਿਟ ਰੱਖਦਾ ਹੈ, ਪਰ ਇੱਕ ਮਜ਼ਬੂਤ plugin ਸਿਸਟਮ, schema-ਮਿੱਤਰ validation, ਅਤੇ serialization ਲਈ ਹੋਰ opinionated ਤਰੀਕੇ ਜੋੜਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ ਇੱਕ ਐਸਾ ਫਰੇਮਵਰਕ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਇੱਕ ਪੂਰੇ ਐਪਲੀਕੇਸ਼ਨ ਪਲੇਟਫਾਰਮ ਵਾਂਗ ਮਹਿਸੂਸ ਹੋਵੇ, ਤਾਂ NestJS ਦੂਜੇ ਪਾਸੇ ਬੈਠਦਾ ਹੈ: ਇਹ controllers/services, dependency injection, ਆਮ ਮੋਡੀਊਲ ਅਤੇ ਇਕ ਸਥਿਰ ਪ੍ਰੋਜੈਕਟ ਸੰਰਚਨਾ ਲਈ conventions ਜੋੜਦਾ ਹੈ।
ਟੀਮਾਂ ਵੀ ਅਕਸਰ "batteries-included" stacks ਵੱਲ ਜਾਂਦੀਆਂ ਹਨ (ਉਦਾਹਰਨ ਲਈ, Next.js API routes) ਜਦੋਂ ਬੈਕਐਂਡ ਇੰਟੀਗ੍ਰੇਟਡ ਹੋ ਕੇ ਫਰੰਟਐਂਡ ਅਤੇ ਡਿਪਲੋਇਮੈਂਟ ਵਰਕਫਲੋ ਨਾਲ ਨਜ਼ਦੀਕੀ ਰਿਹਾ ਹੋਵੇ।
ਜ਼ਿਆਦਾ structured frameworks ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਦਿੰਦੀਆਂ ਹਨ:
ਇਸ ਨਾਲ decision fatigue ਘੱਟ ਹੁੰਦੀ ਹੈ ਅਤੇ ਨਵੇਂ ਡਿਵੈਲਪਰਜ਼ ਦੀ onboarding ਤੇਜ਼ ਹੁੰਦੀ ਹੈ।
ਟਰੇਡ‑ਆਫ ਘੱਟ ਲਚਕ ਅਤੇ ਵੱਡਾ ਸਿੱਖਣ ਯੋਗ ਸਤਹ ਹੈ। ਤੁਸੀਂ ਉਹਨਾਂ ਨਮੂਨਿਆਂ ਨੂੰ ਅਪਣਾਉਣਗੇ ਜੋ ਤੁਹਾਨੂੰ ਲੋੜ ਨਹੀਂ, ਅਤੇ ਅਪਗਰੇਡਾਂ ਵਿੱਚ ਹੋਰ ਹਿੱਸੇ ਜੁੜ ਸਕਦੇ ਹਨ।
Express ਜਾਂ Koa ਨਾਲ, ਤੁਸੀਂ ਠੀਕ ਓਹੀ ਚੀਜ਼ ਜੋੜਦੇ ਹੋ ਜੋ ਲੋੜੀਦਾ ਹੈ—ਪਰ ਉਹਨਾਂ ਚੋਣਾਂ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਵੀ ਤੁਹਾਡੇ ਉੱਤੇ ਹੈ।
ਚੁਣੋ Express/Koa ਜਦੋਂ ਤੁਹਾਨੂੰ ਛੋਟਾ API ਤੇਜ਼ੀ ਨਾਲ ਚਾਹੀਦਾ ਹੋਵੇ, ਟੀਮ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲੇ ਕਰਨ ਵਿੱਚ ਸਹਿਮਤ ਹੋਵੇ, ਜਾਂ ਤੁਸੀਂ ਇੱਕ ਵਿਲੱਖਣ ਲੋੜ ਵਾਲੀ ਸਰਵਿਸ ਬਣਾ ਰਹੇ ਹੋ।
ਚੁਣੋ ਜ਼ਿਆਦਾ opinionated framework ਜਦੋਂ ਸਮਾਂ-ਰੇਖਾ consistency ਮੰਗਦੀ ਹੋਵੇ, ਬਹੁਤ ਹੱਥ ਬਦਲਣਗੇ, ਜਾਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਹਰ ਕੋਈ ਟੀਮ ਇੱਕ "ਇੱਕ ਹੀ ਤਰੀਕਾ" ਅਪਣਾਏ।
Express ਅਤੇ Koa ਇਸ ਲਈ ਲੰਮੇ ਸਮੇਂ ਤੱਕ ਮੌਜੂਦ ਹਨ ਕਿਉਂਕਿ ਉਹ ਲੰਬੀ ਲਿਸਟ ਦੀ ਥਾਂ ਕੁਝ ਟਿਕाऊ ਵਿਚਾਰਾਂ 'ਤੇ ਸ਼ਰਥ ਰੱਖਦੇ ਹਨ। TJ Holowaychuk ਦੀ ਮੁੱਖ ਯੋਗਦਾਨ "ਹੋਰ ਇੱਕ ਰਾਊਟਰ" ਨਹੀਂ ਸੀ—ਇਹ ਸਰਵਰ ਨੂੰ ਛੋਟਾ, ਪੇਸ਼ਗੋਈਯੋਗ, ਅਤੇ ਵਧਾਉਣਯੋਗ ਰੱਖਣ ਦਾ ਤਰੀਕਾ ਸੀ।
ਇੱਕ ਮਿਨੀਮਲ ਕੋਰ ਸਪਸ਼ਟਤਾ ਮਜ਼ਬੂਤ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਇੱਕ ਫਰੇਮਵਰক ਡਿਫਾਲਟ ਵਜੋਂ ਘੱਟ ਕਰਦਾ ਹੈ, ਤੁਸੀਂ ਕਮ ਘੱਲਤ ਫੈਸਲੇ ਕਰਦੇ ਹੋ (ਟੈਂਪਲੇਟਿੰਗ, ORM ਪਸੰਦ, validation ਤਰੀਕ) ਅਤੇ ਵੱਖ-ਵੱਖ ਉਤਪਾਦਾਂ ਲਈ ਅਨੁਕੂਲ ਹੋ ਸਕਦੇ ਹੋ—ਛੋਟੇ webhook receiver ਤੋਂ ਵੱਡੇ web API ਤੱਕ।
Middleware ਪੈਟਰਨ ਅਸਲ ਤਾਕਤ ਹੈ। ਛੋਟੇ, ਇੱਕ‑ਉਦੇਸ਼ੀ ਕਦਮਾਂ (logging, auth, parsing, rate limiting) ਨੂੰ ਜੋੜ ਕੇ, ਤੁਹਾਨੂੰ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਮਿਲਦਾ ਹੈ ਜੋ ਪਾਈਪਲਾਈਨ ਵਾਂਗ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ। Express ਨੇ ਇਸ composition ਨੂੰ ਪ੍ਰਸਿੱਧ ਕੀਤਾ; Koa ਨੇ ਇਸਨੂੰ ਹੋਰ ਸਾਫ ਕੰਟਰੋਲ ਫਲੋ ਨਾਲ ਸੁਧਾਰਿਆ।
ਅਖੀਰ ਕਾਰ, ਕਮਿਊਨਿਟੀ ਐਕਸਟੈਂਸ਼ਨ ਇੱਕ ਫੀਚਰ ਹਨ, ਕੋਈ ਗੜਬੜ ਨਹੀਂ। ਮਿਨੀਮਲ ਫਰੇਮਵਰਕ ਇਕੋਸਿਸਟਮ ਨੂੰ ਸੱਦਦੇ ਹਨ: routers, auth adapters, request validation, observability, background jobs। ਸਭ ਤੋਂ ਵਧੀਆ ਟੀਮ ਇਨ੍ਹਾਂ ਨੂੰ ਇਰਾਦੇ ਨਾਲ ਢਾਲਦੇ ਹਨ ਨਾ ਕਿ ਬੇਤਰਤੀਬੀ ਨਾਲ ਜੋੜਦੇ।
ਆਪਣੀ ਟੀਮ ਦੀ ਪਸੰਦ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਖ਼ਤਰੇ ਦੇ ਅਨੁਸਾਰ ਫਰੇਮਵਰਕ ਚੁਣੋ:
ਕਿਸੇ ਵੀ ਹਾਲਤ ਵਿੱਚ, ਤੁਹਾਡੇ ਅਸਲ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲੇ ਫਰੇਮਵਰਕ ਦੇ ਉੱਪਰ ਰਹਿੰਦੇ ਹਨ: ਕਿਵੇਂ input validate ਕਰਨਾ, ਮੋਡੀਊਲ ਸੰਰਚਨਾ, error handling, ਅਤੇ production ਨਿਗਰਾਨੀ।
ਜੇ ਤੁਸੀਂ ਮਿਨੀਮਲ ਫਿਲਾਸਫੀ ਪਸੰਦ ਕਰਦੇ ਹੋ ਪਰ ਤੇਜ਼ੀ ਨਾਲ ਸ਼ਿਪ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Koder.ai ਵਰਗਾ vibe-coding ਪਲੇਟਫਾਰਮ ਇੱਕ ਉਪਯੋਗੀ ਸਹਾਇਕ ਹੋ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ API ਨੂੰ ਆਮ ਭਾਸ਼ਾ ਵਿੱਚ ਵਰਣਨ ਕਰਕੇ ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ web + backend scaffold ਤਿਆਰ ਕਰਵਾ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ Express/Koa ਸਿਧਾਂਤ—ਛੋਟੀ middleware ਲੇਅਰਾਂ, ਸਾਫ ਸਰਹੱਦ, ਸਪਸ਼ਟ ਡੀਪੈਂਡੈਂਸੀ—ਲਗਾ ਕੇ ਅੱਗੇ ਵਧ ਸਕਦੇ ਹੋ। Koder.ai source code export, snapshots/rollback, ਅਤੇ deployment/hosting ਨੂੰ ਸਹਿਯੋਗ ਦਿੰਦਾ ਹੈ, ਜੋ ਮਿਨੀਮਲ ਫਰੇਮਵਰਕਾਂ ਦੁਆਰਾ ਜਾਣੀ-ਜੁੜੀ operational ਝੰਝਟ ਘਟਾ ਸਕਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ ਇੱਕ Node ਸੇਵਾ ਦਾ ਨਕ਼ਸ਼ਾ ਬਣਾ ਰਹੇ ਹੋ, ਤਾਂ /blog ਵਿੱਚ ਹੋਰ ਗਾਇਡ ਦੇਖੋ। ਜੇ ਤੁਸੀਂ ਟੂਲ ਜਾਂ ਸਹਾਇਤਾ ਵਿਕਲਪਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰ ਰਹੇ ਹੋ ਤਾਂ /pricing ਵੇਖੋ।
Express ਅਤੇ Koa ਇੱਕ ਛੋਟਾ HTTP ਕੋਰ ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਦੇ ਹਨ: ਰਾਊਟਿੰਗ ਅਤੇ middleware ਪਾਈਪਲਾਈਨ। ਇਹ ਝटका-ਝਟਕਾ ਦੇ ਕੇ ਆਥ, ਡੈਟਾਬੇਸ ਐਕਸੈੱਸ, ਬੈਕਗਰਾਉਂਡ ਜਾਬਜ਼ ਜਾਂ ਪ੍ਰੋਜੈਕਟ ਸਟ੍ਰੱਕਚਰ ਵਰਗੀਆਂ ਰਾਇਆਂ ਇਕੱਠੀਆਂ ਨਹੀਂ ਕਰਦੇ — ਇਸ ਲਈ ਤੁਸੀਂ ਆਪਣੀ ਸੇਵਾ ਲਈ ਜਰੂਰੀ ਚੀਜ਼ਾਂ ਹੀ ਜੋੜਦੇ ਹੋ।
ਇਸ ਨਾਲ ਫਰੇਮਵਰਕ ਸਿੱਖਣਾ ਆਸਾਨ ਰਹਿੰਦਾ ਹੈ ਅਤੇ ਸਮੇਂ ਦੇ ਨਾਲ ਸਥਿਰ ਰਹਿੰਦਾ ਹੈ, ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ ਬਾਕੀ ਸਟੈਕ ਚੁਣਨਾ ਅਤੇ ਜੋੜਨਾ ਤੁਹਾਡੇ ਉੱਤੇ ਹੀ ਹੁੰਦਾ ਹੈ।
Middleware ਬੇਨਤੀ ਸੰਭਾਲਣ ਨੂੰ ਛੋਟੇ-ਛੋਟੇ ਇਕਾਈਆਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ ਜੋ ਇੱਕ-ਦੇ-ਬਾਅਦ ਇਕ-ਇੱਕ ਕੰਮ ਕਰਦੀਆਂ ਹਨ (ਉਦਾਹਰਨ: logging → body parsing → auth → validation → route handler → error handling)।
ਇਸ ਨਾਲ ਬਿਹੇਵਿਯਰ ਕੰਪੋਜ਼ेबल ਬਣ ਜਾਂਦਾ ਹੈ: ਤੁਸੀਂ ਇੱਕ ਕਦਮ (ਜਿਵੇਂ auth) ਬਦਲ ਸਕਦੇ ਹੋ ਬਿਨਾਂ ਪੂਰੇ ਐਪ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣ ਦੇ, ਅਤੇ ਇੱਕ ਹੀ middleware ਸੈੱਟ ਨੂੰ ਕਈ ਸਰਵਿਸਿਜ਼ ਵਿੱਚ ਸਾਂਝਾ ਕਰ ਸਕਦੇ ਹੋ।
ਜਦੋਂ ਤੁਸੀਂ ਸਭ ਤੋਂ ਤੇਜ਼ ਰਾਹ ਚਾਹੁੰਦੇ ਹੋ ਇੱਕ ਕਾਰਗਰ ਸਰਵਿਸ ਬਣਾਉਣ ਦਾ ਅਤੇ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਭਾਦਰਾ ਚਾਹੀਦਾ ਹੋ, ਤਾਂ Express ਚੁਣੋ।
ਆਮ ਕਾਰਨ:
ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਹੋਰ ਸਲਿਮ ਕੋਰ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਕੁਝ ਚੀਜ਼ਾਂ ਖੁਦ ਚੁਣਨ ਲਈ ਤਿਆਰ ਹੋ।
ਇਹ ਬਹੁਤ ਵਧੀਆ ਹੈ ਜਦੋਂ:
async/await ਨਿਯਮਬੱਧ ਫਲੋ ਚਾਹੁੰਦੇ ਹੋExpress ਵਿਚ middleware ਆਮ ਤੌਰ 'ਤੇ (req, res, next) ਵਰਗੀ ਹੁੰਦੀ ਹੈ ਅਤੇ failure ਨੂੰ ਕੇਂਦਰਿਤ ਕਰਨ ਲਈ ਇੱਕ error middleware (ਜਿਸਦੇ ਚਾਰ arguments ਹੁੰਦੇ ਹਨ) ਵਰਤਦੇ ਹੋ।
Koa middleware ਆਮ ਤੌਰ async (ctx, next) ਹੁੰਦਾ ਹੈ ਅਤੇ ਆਮ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ middleware ਸਟੈਕ ਦੇ ਉਪਰ ਇੱਕ try/catch ਰੱਖ ਕੇ await next() ਨੂੰ ਘੇਰਿਆ ਜਾਂਦਾ ਹੈ।
ਦੋਹਾਂ ਹਾਲਤਾਂ ਵਿੱਚ, ਲਕੜੀ ਵਾਲੇ ਕੋਡ ਤੋਂ ਬਚੋ ਅਤੇ ਪੇਸ਼ ਕਰੋ:
“ਐਜ ਤੋਂ ਅੰਦਰਲਾ” ਹੱਦਬੰਦੀ ਰੱਖੋ:
/web: ਰਾਊਟ/ਕੋਨਟਰੋਲਰ, ਬੇਨਤੀ parsing, response shaping/domain: ਕਾਰੋਬਾਰੀ ਲਾਜਿਕ (ਸੇਵਾਵਾਂ/use-cases)/data: ਪर्सਿਸਟੈਂਸ (repositories/ਕੁਐਰੀਜ਼)ਉਹਨਾਂ ਲੇਅਰਾਂ ਦੇ ਅੰਦਰ ਫੀਚਰ ਦੇ ਆਧਾਰ 'ਤੇ ਕੋਡ ਗਰੂਪ ਕਰੋ (ਜਿਵੇਂ , ) ਤਾਂ ਕਿ ਬਦਲਾਅ ਸਥਾਨਕ ਰਹਿਣ।
ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਉਤਪਾਦਕ API ਲਈ ਨਿਮਨਲਿਖਤ ਬੇਸਲਾਈਨ ਵਰਤੋਂਯੋਗ ਮਿਡਲਵੇਅਰ:
ਚੇਨ ਛੋਟੀ ਅਤੇ ਹਰ ਇਕ ਲੇਅਰ ਦੀ ਇੱਕ ਹੀ ਜ਼ਿੰਮੇਵਾਰੀ ਹੋਵੇ; ਕਿਸੇ ਵੀ ordering constraints ਨੂੰ ਦਸਤਾਵੇਜ਼ ਕਰੋ।
ਸੁਰੱਖਿਆ ਦੇ ਮੁਢਲੇ ਨੁਕਤੇ ਜੋ ਤੁਹਾਨੂੰ ਖੁਦ ਸ਼ਾਮਲ ਕਰਨੇ ਪੈਣਗੇ:
Middleware ਕੰਫਿਗਰੇਸ਼ਨ ਨੂੰ ਸੁਰੱਖਿਆ-ਸੰਵੇਦਨਸ਼ੀਲ ਸਮਝੋ, ਨਾਂ ਕਿ ਵਿਕਲਪਿਕ।
ਇਕ ਛੋਟੀ “ਸਟੈਂਡਰਡ ਸਟੈਕ” ਬਣਾਓ ਅਤੇ ਤੀਸਰੇ-ਪੱਖ ਦੇ ਪੈਕੇਜਾਂ ਨੂੰ ਉਤਪਾਦ ਕੋਡ ਵਾਂਗ ਵਰਤੋ:
npm audit) ਚਲਾਓ ਅਤੇ ਅਣਉਪਯੋਗ ਪੈਕੇਜ ਹਟਾਓਮਿਨੀਮਲ ਇਕੋਸਿਸਟਮ ਵਿੱਚ, ਜ਼ਿਆਦਾਤਰ ਖਤਰਾ dependencies ਤੋਂ ਆਉਂਦਾ ਹੈ, ਨਾ ਕਿ ਰਾਊਟਰ ਤੋਂ।
ਜਦੋਂ consistency ਅਤੇ scaffolding ਫਲਦਾਇਕ ਹੋਣ ਤਾਂ ਜ਼ਿਆਦਾ opinionated ਫਰੇਮਵਰਕ ਚੁਣੋ:
ਸਧਾਰਨ ਸਿਗਨਲ:
ਜੇ ਤੁਹਾਡਾ ਮੁੱਖ ਕੰਮ HTTP endpoints ਬਣਾਉਣਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਸੰਰਚਨਾ 'ਤੇ ਪੂਰਾ ਕੰਟਰੋਲ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ Express/Koa ਅਜੇ ਵੀ ਮਜ਼ਬੂਤ ਚੋਣ ਹਨ।
{ code, message, details }) ਤਾਂ ਕਿ ਕਲਾਇੰਟ ਨੂੰ ਅਨੁਮਾਨ ਨਾ ਲਗੇ।usersbilling