lieko-express 0.0.20 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eiwSrvt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,387 @@
-doc to finish
+# Lieko Express
+
+A modern, minimal, Express-like framework for Node.js with built-in body parsing, CORS, validation, and more. Lieko-express is designed to be a drop-in replacement for Express.js with additional features and better performance.
+
+Online documentation
+[Lieko Express Documentation](https://express.lieko.app/)
+
+## Key Features
+
+- **Express-compatible API**: Familiar routing, middleware, and request/response handling.
+- **Built-in Body Parsing**: JSON, URL-encoded, and multipart form-data support.
+- **CORS Support**: Configurable cross-origin resource sharing with flexible options.
+- **Schema Validation**: Built-in validation system with comprehensive validators.
+- **Static File Serving**: Efficient static file middleware with caching and ETags.
+- **Template Engine**: Simple HTML templating with support for custom engines.
+- **Route Groups**: Organize routes with nested groups and shared middleware.
+- **Debug Mode**: Detailed request logging with timing and payload information.
+
+> **Note**: Lieko-express requires Node.js ≥14.0.0.
+
+## Installation
+
+### NPM
+```bash
+npm install lieko-express
+```
+
+### Yarn
+```bash
+yarn add lieko-express
+```
+
+## Quick Start
+
+Create your first Lieko-express application:
+
+```javascript
+const Lieko = require('lieko-express');
+const app = Lieko();
+
+app.get('/', (req, res) => {
+  res.json({ message: 'Hello World!' });
+});
+
+app.listen(3000, () => {
+  console.log('Server running on http://localhost:3000');
+});
+```
+
+### Basic REST API Example
+
+```javascript
+const Lieko = require('lieko-express');
+const app = Lieko();
+
+// Enable debug mode
+app.debug(true);
+
+// Simple in-memory database
+const users = [];
+let idCounter = 1;
+
+// Get all users
+app.get('/api/users', (req, res) => {
+  res.json(users);
+});
+
+// Get user by ID
+app.get('/api/users/:id', (req, res) => {
+  const user = users.find(u => u.id === req.params.id);
+  
+  if (!user) {
+    return res.status(404).json({ 
+      error: 'User not found' 
+    });
+  }
+  
+  res.json(user);
+});
+
+// Create user
+app.post('/api/users', (req, res) => {
+  const user = {
+    id: String(idCounter++),
+    name: req.body.name,
+    email: req.body.email,
+    createdAt: new Date().toISOString()
+  };
+  
+  users.push(user);
+  res.status(201).json(user);
+});
+
+// Update user
+app.patch('/api/users/:id', (req, res) => {
+  const user = users.find(u => u.id === req.params.id);
+  
+  if (!user) {
+    return res.status(404).json({ 
+      error: 'User not found' 
+    });
+  }
+  
+  Object.assign(user, req.body);
+  res.json(user);
+});
+
+// Delete user
+app.delete('/api/users/:id', (req, res) => {
+  const index = users.findIndex(u => u.id === req.params.id);
+  
+  if (index === -1) {
+    return res.status(404).json({ 
+      error: 'User not found' 
+    });
+  }
+  
+  users.splice(index, 1);
+  res.status(204).end();
+});
+
+app.listen(3000, () => {
+  console.log('API running on http://localhost:3000');
+});
+```
+
+## Configuration
+
+Customize Lieko-express with settings:
+
+```javascript
+const app = Lieko();
+
+// Enable/disable features
+app.set('x-powered-by', 'MyApp');
+app.set('trust proxy', true);
+app.set('views', './templates');
+app.set('view engine', 'html');
+
+// Enable debug mode
+app.debug(true);
+
+// Disable strict trailing slash
+app.set('strictTrailingSlash', false);
+app.set('allowTrailingSlash', true);
+```
+
+### Configuration Options
+
+| Setting              | Type          | Default       | Description                     |
+|----------------------|---------------|---------------|---------------------------------|
+| `debug`             | boolean      | false        | Enable detailed request logging |
+| `x-powered-by`      | string\|boolean | 'lieko-express' | X-Powered-By header value     |
+| `trust proxy`       | boolean      | false        | Trust X-Forwarded-* headers     |
+| `strictTrailingSlash` | boolean    | true         | Strict trailing slash matching  |
+| `allowTrailingSlash` | boolean     | true         | Allow optional trailing slash   |
+| `views`             | string       | './views'    | Template directory path         |
+| `view engine`       | string       | 'html'       | Default template engine         |
+
+## Routing
+
+Define routes with flexible patterns:
+
+```javascript
+// GET request
+app.get('/users', (req, res) => {
+  res.json({ users: [] });
+});
+
+// POST request
+app.post('/users', (req, res) => {
+  res.status(201).json({ message: 'User created' });
+});
+
+// Route parameters
+app.get('/users/:id', (req, res) => {
+  const userId = req.params.id;
+  res.json({ userId });
+});
+
+// Multiple handlers
+app.get('/protected', authMiddleware, (req, res) => {
+  res.json({ message: 'Protected route' });
+});
+```
+
+## Middleware
+
+Middleware for request processing:
+
+```javascript
+// Application-level
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.url}`);
+  next();
+});
+
+// Error handling
+app.errorHandler((err, req, res, next) => {
+  console.error('Error:', err.message);
+  res.status(err.status || 500).json({
+    error: {
+      message: err.message,
+      code: err.code || 'SERVER_ERROR'
+    }
+  });
+});
+```
+
+## Request Object
+
+Properties and methods:
+
+| Property          | Type    | Description                          |
+|-------------------|---------|--------------------------------------|
+| `req.body`       | object | Parsed request body                  |
+| `req.params`     | object | Route parameters                     |
+| `req.query`      | object | Query string parameters              |
+| `req.files`      | object | Uploaded files                       |
+| `req.headers`    | object | HTTP headers                         |
+| `req.method`     | string | HTTP method                          |
+
+Methods like `req.get('Content-Type')`, `req.accepts(['json', 'html'])`.
+
+## Response Object
+
+Methods for sending responses:
+
+```javascript
+// Send JSON
+res.json({ message: 'Hello' });
+
+// Status and helpers
+res.status(201).json({ message: 'Created' });
+res.ok({ data: users });
+res.created({ user });
+res.noContent();
+res.badRequest('Invalid input');
+res.redirect('/new-url');
+```
+
+## Body Parsing
+
+Automatic parsing with limits:
+
+```javascript
+app.bodyParser({
+  limit: '50mb',
+  extended: true,
+  strict: true
+});
+```
+
+## CORS
+
+Configure CORS:
+
+```javascript
+app.cors({
+  origin: '*',
+  methods: ['GET', 'POST'],
+  credentials: true
+});
+```
+
+## Static Files
+
+Serve static files:
+
+```javascript
+app.use(app.static('public'));
+```
+
+## Template Engine
+
+Render templates:
+
+```javascript
+res.render('index', {
+  title: 'My Page',
+  user: { name: 'Alice' }
+});
+```
+
+## Schema Validation
+
+Validate requests:
+
+```javascript
+const { Schema, validators: v, validate } = require('lieko-express');
+
+const schema = new Schema({
+  name: [v.required(), v.string(), v.minLength(3)],
+  age: [v.optional(), v.number(), v.min(18)]
+});
+
+app.post('/users', validate(schema), (req, res) => {
+  res.created(req.body);
+});
+```
+
+## Route Groups
+
+Organize routes:
+
+```javascript
+app.group('/api', (api) => {
+  api.get('/users', handler);
+  api.post('/users', handler);
+});
+```
+
+## Error Handling
+
+Custom handlers:
+
+```javascript
+app.notFound((req, res) => {
+  res.notFound('Page not found');
+});
+```
+
+## Cookies
+
+Set and clear cookies:
+
+```javascript
+res.cookie('session', 'abc123', {
+  maxAge: 86400000,
+  httpOnly: true,
+  secure: true
+});
+
+res.clearCookie('session');
+```
+
+## File Uploads
+
+Handle uploads:
+
+```javascript
+app.post('/upload', (req, res) => {
+  const file = req.files.avatar;
+  // Process file
+});
+```
+
+## API Methods Reference
+
+See the full documentation for complete lists of application and response methods.
+
+## Validators Reference
+
+Built-in validators like `v.required()`, `v.email()`, `v.min(10)`.
+
+## Best Practices
+
+- Use modular routes and controllers.
+- Handle environment variables with `dotenv`.
+- Implement security headers.
+- Add rate limiting for APIs.
+
+## Examples
+
+### Basic REST API
+
+(See code in Quick Start)
+
+### Authentication
+
+JWT-based auth example (see full code in documentation).
+
+### File Upload
+
+Upload service example (see full code in documentation).
+
+### Real-world App
+
+Blog API with auth and posts (see full code in documentation).
+
+## Contributing
+
+Contributions welcome! Please submit issues or pull requests on GitHub.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

package/lib/cors.js

@@ -56,7 +56,6 @@ module.exports = function cors(userOptions = {}) {
             if (!allowed) {
                 res.statusCode = 403;
                 return res.end(JSON.stringify({
-                    success: false,
                     error: "Origin Forbidden",
                     message: `Origin "${requestOrigin}" is not allowed`
                 }));

package/lib/schema.js

@@ -371,15 +371,11 @@ function validate(schema) {
         try {
             schema.validate(req.body);
             next();
-        } catch (error) {
-            if (error instanceof ValidationError) {
-                return res.status(400).json({
-                    success: false,
-                    message: 'Validation failed',
-                    errors: error.errors
-                });
+        } catch (err) {
+            if (err instanceof ValidationError) {
+                return res.status(400).json({ error: { status: 400, type: "VALIDATION_ERROR", message: 'Validation failed', details: err.errors } });
             }
-            throw error;
+            throw err;
         }
     };
 }

package/lieko-express.js

@@ -781,7 +781,8 @@ ${cyan}    (req, res, next) => {
       return res.status(500).json({
         error: {
           message: "Internal Server Error",
-          code: 500
+          status: 500,
+          type: "InternalServerError"
         }
       });
     }
@@ -812,7 +813,7 @@ ${cyan}    (req, res, next) => {
       res.status(500).json({
         error: {
           message: "Internal Server Error",
-          code: 500
+          status: 500
         }
       });
     }
@@ -827,13 +828,12 @@ ${cyan}    (req, res, next) => {
       return res.status(500).json({
         error: {
           message: "Invalid error format passed to res.error()",
-          code: 500
+          status: 500
         }
       });
     }
 
     const HTTP_STATUS = {
-      // 4xx – CLIENT ERRORS
       INVALID_REQUEST: 400,
       VALIDATION_FAILED: 400,
       NO_TOKEN_PROVIDED: 401,
@@ -844,18 +844,21 @@ ${cyan}    (req, res, next) => {
       CONFLICT: 409,
       RECORD_EXISTS: 409,
       TOO_MANY_REQUESTS: 429,
-
-      // 5xx – SERVER ERRORS
       SERVER_ERROR: 500,
       SERVICE_UNAVAILABLE: 503
     };
 
-    const status = errorObj.status || HTTP_STATUS[errorObj.code] || 500;
+    let currentStatus = res.statusCode || 200;
+    let desiredStatus = errorObj.status || HTTP_STATUS[errorObj.status];
+
+    const finalStatus = (currentStatus >= 400 && currentStatus < 600)
+      ? currentStatus
+      : (desiredStatus || 500);
 
-    return res.status(status).json({
+    return res.status(finalStatus).json({
       error: {
         message: errorObj.message || 'An error occurred',
-        code: errorObj.code || 500,
+        status: errorObj.status || finalStatus,
         ...errorObj
       }
     });
@@ -982,7 +985,7 @@ ${cyan}    (req, res, next) => {
           return res.status(413).json({
             error: {
               message: 'Payload Too Large',
-              code: 413
+              status: 413
             }
           });
         }
@@ -1032,7 +1035,7 @@ ${cyan}    (req, res, next) => {
 
       if (!route) {
         if (this.notFoundHandler) return this.notFoundHandler(req, res);
-        return res.status(404).json({ error: { message: 'Route not found', code: 404 } });
+        return res.status(404).error('Not Found');
       }
 
       req.params = route.params;
@@ -1058,7 +1061,11 @@ ${cyan}    (req, res, next) => {
 
       if (res.headersSent) return;
 
-      await route.handler(req, res);
+      await route.handler(req, res, (err) => {
+        if (err) {
+          return this._runErrorHandlers(err, req, res);
+        }
+      });
 
     } catch (error) {
       if (!res.headersSent) {
@@ -1138,16 +1145,21 @@ ${cyan}    (req, res, next) => {
         .map(item => item.type);
     };
 
-    const accepts = (types) => {
+    const acceptedTypes = parseAccept(req.headers['accept']);
+
+    req.accepts = function (types) {
+      if (arguments.length === 0) {
+        return acceptedTypes;
+      }
+
       if (!Array.isArray(types)) types = [types];
-      const accepted = parseAccept(req.headers['accept']);
 
       for (const type of types) {
         const t = type.toLowerCase();
 
-        if (accepted.includes(t)) return type;
+        if (acceptedTypes.includes(t)) return type;
 
-        if (accepted.some(a => {
+        if (acceptedTypes.some(a => {
           if (a === '*/*') return true;
           if (a.endsWith('/*')) {
             const prefix = a.slice(0, -1);
@@ -1162,8 +1174,24 @@ ${cyan}    (req, res, next) => {
       return false;
     };
 
-    req.accepts = function (types) {
-      return accepts(types);
+    req.responseType = function () {
+      const accepted = this.accepts();
+
+      if (accepted.length > 0) {
+        for (const type of accepted) {
+          if (type === 'text/html') return 'html';
+          if (type === 'application/json') return 'json';
+          if (type === '*/*') break;
+        }
+      }
+
+      const ua = (this.headers['user-agent'] || '').toLowerCase();
+      const isApi = ua.includes('curl') ||
+        ua.includes('postman') ||
+        this.xhr ||
+        this.headers['content-type']?.includes('application/json');
+
+      return isApi ? 'json' : 'html';
     };
 
     req.acceptsLanguages = function (langs) {
@@ -1538,6 +1566,7 @@ ${cyan}    (req, res, next) => {
           status = 404;
           message = 'File Not Found';
           details = `The file "${filePath}" does not exist.\nFull path tried: ${file}`;
+          console.error(details, err);
         } else if (err.code === 'FORBIDDEN') {
           status = 403;
           message = 'Forbidden';
@@ -1576,11 +1605,9 @@ ${cyan}    (req, res, next) => {
       if (message !== undefined) payload.message = message;
       return res.json(payload);
     };
-    //res.success = res.ok;
 
     res.created = (data, message = 'Resource created successfully') => {
-      const payload = { success: true, data, message };
-      return res.status(201).json(payload);
+      return res.status(201).json({ data, message });
     };
 
     res.noContent = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lieko-express",
-  "version": "0.0.20",
+  "version": "1.0.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/eiwSrvt/lieko-express"