fullstx 1.0.0

package/README.md

@@ -0,0 +1,86 @@
+# fullstx
+
+A high-performance, custom backend framework with a static file frontend. Equipped with built-in **browser-sync** for automatic hot-reload during development.
+
+## Features
+
+- **🚀 Radix Trie Router**: O(1) routing performance for maximum speed.
+- **🔄 Built-in Hot-Reloading**: Seamless development with integrated `browser-sync`. Proxies your app and reloads the browser when static files or server code changes.
+- **🛡️ Secure by Default**: Helmet (security headers), CORS, XSS protection, and rate-limiting built-in.
+- **🗜️ Auto-Compression**: Gzip and Brotli compression out of the box.
+- **🧩 Extensible**: Built-in support for Sessions, SQLite, Knex, WebSockets, HTMX, and Sentry.
+
+## Installation
+
+```bash
+npm install fullstx
+```
+
+## Configuration
+
+Pass options when creating the Framework instance:
+
+```js
+const Framework = require('fullstx');
+
+const app = Framework({
+  // --- Development & Server ---
+  port: 3000,                  // Public port (default: 3000)
+  internalPort: undefined,     // Override internal port manually
+  internalPortOffset: 1000,    // Offset for internal server when liveReload is true
+  liveReload: true,            // Enable/disable browser-sync hot-reload
+  staticDir: "public",         // Directory for static files (default: "public")
+
+  // --- Core Middlewares ---
+  logger: true,                // Enable HTTP request logging
+  cors: true,                  // Enable Cross-Origin Resource Sharing
+  helmet: true,                // Enable Security Headers (Helmet)
+  xss: true,                   // Enable XSS Protection / Sanitization
+  compression: true,           // Enable Gzip/Brotli Compression
+  healthCheck: true,           // Enable /api/health endpoint
+
+  // --- Features ---
+  session: false,              // Enable Sessions (requires Redis/Memory config)
+  htmx: true,                  // Enable HTMX helpers (req.htmx, res.hxRedirect, etc)
+  jwtSecret: process.env.JWT_SECRET || "supersecret", // Secret for JWT signing
+  
+  // --- Integrations ---
+  db: null,                    // Database configuration (Knex)
+  ws: null,                    // WebSocket / Redis PubSub config
+  sqlite: null,                // SQLite specific config
+  sentry: null                 // Sentry error tracking config
+});
+
+app.listen(3000);
+```
+
+Example: server directly on port 3000 (without browser-sync proxy):
+```js
+const app = Framework({ liveReload: false });
+app.listen(3000);
+```
+
+## Troubleshooting
+
+- **Port already in use** — another process is using port 3000 or 4000. Stop that process, or reset the port:
+  ```js
+  const app = Framework({ internalPort: 4100 }); // force internal port
+  app.listen(3000);
+  ```
+
+- **File changes but browser doesn't reload** — ensure the file is in the `watch` list in the Framework options.
+
+## Notes
+
+- The framework automatically handles browser-sync internally — no need to install/configure browser-sync separately.
+- Production mode: set `liveReload: false` so there is no browser-sync overhead.
+- Static files are served by the `serveStaticFile` middleware in `app.js`.
+
+## Testing
+
+### Internal Framework Testing
+The framework's internal engine is tested using Jest to maintain stability and performance.
+
+```bash
+npm run test
+```

package/bin/create.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+
+const projectName = process.argv[2];
+
+if (!projectName) {
+    console.log('Usage: create-fullstx <project-name>');
+    process.exit(1);
+}
+
+const projectPath = path.join(process.cwd(), projectName);
+
+if (fs.existsSync(projectPath)) {
+    console.log(`Folder ${projectName} already exists.`);
+    process.exit(1);
+}
+
+console.log('Creating Project...');
+
+fs.mkdirSync(projectPath);
+fs.mkdirSync(path.join(projectPath, 'pages'));
+fs.mkdirSync(path.join(projectPath, 'public'));
+
+const packageJson = {
+    name: projectName,
+    version: '1.0.0',
+    main: 'app.js',
+    scripts: {
+        start: 'node app.js'
+    },
+    dependencies: {
+        fullstx: '*'
+    }
+};
+
+fs.writeFileSync(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 4));
+
+const appJs = `const Framework = require("fullstx");
+
+const app = Framework();
+
+app.get("/", (req, res) => {
+    res.end("Hello World");
+});
+
+app.listen(3000);
+`;
+
+fs.writeFileSync(path.join(projectPath, 'app.js'), appJs);
+
+const indexPage = `module.exports = () => \`
+<html>
+<body>
+<h1>Hello from fullstx</h1>
+</body>
+</html>
+\`;
+`;
+
+fs.writeFileSync(path.join(projectPath, 'pages', 'index.js'), indexPage);
+
+console.log(`Project ${projectName} created successfully.`);
+console.log('Run:');
+console.log(`  cd ${projectName}`);
+console.log('  npm install');
+console.log('  npm start');
+console.log('');
+console.log('Hot-reload (browser-sync) otomatis aktif via framework fullstx.');

package/bin/generate.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const path = require('path');
+
+const type = process.argv[2];
+const name = process.argv[3];
+
+if (!type || !name) {
+    console.error('Usage: fullstx-generate <type> <name>');
+    console.error('Types: controller, service, module');
+    process.exit(1);
+}
+
+const targetDir = path.join(process.cwd(), 'src', type + 's');
+if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+}
+
+const upperName = name.charAt(0).toUpperCase() + name.slice(1);
+const fileName = `${upperName}${type.charAt(0).toUpperCase() + type.slice(1)}.js`;
+const targetPath = path.join(targetDir, fileName);
+
+if (fs.existsSync(targetPath)) {
+    console.error(`[!] File already exists: ${targetPath}`);
+    process.exit(1);
+}
+
+let content = '';
+
+if (type === 'controller') {
+    content = `module.exports = {
+    index(req, res) {
+        if (res.json) return res.json({ message: "List ${name}s" });
+        res.end("List ${name}s");
+    },
+    show(req, res) {
+        if (res.json) return res.json({ message: "Show ${name}" });
+        res.end("Show ${name}");
+    },
+    create(req, res) {
+        if (res.json) return res.json({ message: "Create ${name}" });
+        res.end("Create ${name}");
+    },
+    update(req, res) {
+        if (res.json) return res.json({ message: "Update ${name}" });
+        res.end("Update ${name}");
+    },
+    destroy(req, res) {
+        if (res.json) return res.json({ message: "Delete ${name}" });
+        res.end("Delete ${name}");
+    }
+};
+`;
+} else if (type === 'service') {
+    content = `class ${upperName}Service {
+    constructor() {}
+    
+    async findAll() {
+        return [];
+    }
+}
+
+module.exports = ${upperName}Service;
+`;
+} else if (type === 'module') {
+    content = `module.exports = function(app) {
+    app.get('/${name.toLowerCase()}s', (req, res) => {
+        if (res.json) return res.json({ message: "${upperName} module works!" });
+        res.end("${upperName} module works!");
+    });
+};
+`;
+} else {
+    console.error('Unknown type: ' + type);
+    process.exit(1);
+}
+
+fs.writeFileSync(targetPath, content);
+console.log(`[fullstx] Successfully created ${type} at src/${type}s/${fileName}`);