@engjts/nexus 0.1.0

package/package.json

@@ -0,0 +1,178 @@
+{
+  "name": "@engjts/nexus",
+  "version": "0.1.0",
+  "description": "Nexus framework async-first web framework with type-safety and security built-in",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "nexus": "./dist/cli/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js",
+      "require": "./dist/core/index.js"
+    },
+    "./database": {
+      "types": "./dist/database/index.d.ts",
+      "import": "./dist/database/index.js",
+      "require": "./dist/database/index.js"
+    },
+    "./graphql": {
+      "types": "./dist/advanced/graphql/index.d.ts",
+      "import": "./dist/advanced/graphql/index.js",
+      "require": "./dist/advanced/graphql/index.js"
+    },
+    "./cache": {
+      "types": "./dist/advanced/cache/index.d.ts",
+      "import": "./dist/advanced/cache/index.js",
+      "require": "./dist/advanced/cache/index.js"
+    },
+    "./jobs": {
+      "types": "./dist/advanced/jobs/index.d.ts",
+      "import": "./dist/advanced/jobs/index.js",
+      "require": "./dist/advanced/jobs/index.js"
+    },
+    "./sentry": {
+      "types": "./dist/advanced/sentry/index.d.ts",
+      "import": "./dist/advanced/sentry/index.js",
+      "require": "./dist/advanced/sentry/index.js"
+    },
+    "./realtime": {
+      "types": "./dist/advanced/realtime/index.d.ts",
+      "import": "./dist/advanced/realtime/index.js",
+      "require": "./dist/advanced/realtime/index.js"
+    },
+    "./testing": {
+      "types": "./dist/advanced/testing/index.d.ts",
+      "import": "./dist/advanced/testing/index.js",
+      "require": "./dist/advanced/testing/index.js"
+    },
+    "./security": {
+      "types": "./dist/security/index.d.ts",
+      "import": "./dist/security/index.js",
+      "require": "./dist/security/index.js"
+    },
+    "./deployment": {
+      "types": "./dist/deployment/index.d.ts",
+      "import": "./dist/deployment/index.js",
+      "require": "./dist/deployment/index.js"
+    },
+    "./swagger": {
+      "types": "./dist/advanced/swagger/index.d.ts",
+      "import": "./dist/advanced/swagger/index.js",
+      "require": "./dist/advanced/swagger/index.js"
+    },
+    "./postman": {
+      "types": "./dist/advanced/postman/index.d.ts",
+      "import": "./dist/advanced/postman/index.js",
+      "require": "./dist/advanced/postman/index.js"
+    },
+    "./playground": {
+      "types": "./dist/advanced/playground/index.d.ts",
+      "import": "./dist/advanced/playground/index.js",
+      "require": "./dist/advanced/playground/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "core": [
+        "dist/core/index.d.ts"
+      ],
+      "database": [
+        "dist/database/index.d.ts"
+      ],
+      "graphql": [
+        "dist/advanced/graphql/index.d.ts"
+      ],
+      "cache": [
+        "dist/advanced/cache/index.d.ts"
+      ],
+      "jobs": [
+        "dist/advanced/jobs/index.d.ts"
+      ],
+      "sentry": [
+        "dist/advanced/sentry/index.d.ts"
+      ],
+      "realtime": [
+        "dist/advanced/realtime/index.d.ts"
+      ],
+      "testing": [
+        "dist/advanced/testing/index.d.ts"
+      ],
+      "security": [
+        "dist/security/index.d.ts"
+      ],
+      "deployment": [
+        "dist/deployment/index.d.ts"
+      ],
+      "swagger": [
+        "dist/advanced/swagger/index.d.ts"
+      ],
+      "postman": [
+        "dist/advanced/postman/index.d.ts"
+      ],
+      "playground": [
+        "dist/advanced/playground/index.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "test": "jest",
+    "benchmark": "ts-node benchmarks/index.ts",
+    "nexus": "ts-node src/cli/bin.ts",
+    "postbuild": "chmod +x dist/cli/bin.js"
+  },
+  "keywords": [
+    "framework",
+    "web",
+    "async",
+    "typescript",
+    "http",
+    "server"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "mysql2": "^3.15.3",
+    "zod": "^3.22.4"
+  },
+  "peerDependencies": {
+    "graphql": "^16.0.0",
+    "ioredis": "^5.0.0",
+    "ws": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "graphql": {
+      "optional": true
+    },
+    "ws": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.0",
+    "@types/ws": "^8.18.1",
+    "graphql": "^16.8.1",
+    "ioredis": "^5.3.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
+    "ws": "^8.16.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/public/css/style.css

@@ -0,0 +1,87 @@
+/* Nexus Framework - Sample Styles */
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    color: #fff;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.container {
+    max-width: 800px;
+    padding: 40px;
+    text-align: center;
+}
+
+h1 {
+    font-size: 3rem;
+    margin-bottom: 20px;
+    background: linear-gradient(90deg, #00d9ff, #00ff88);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+p {
+    font-size: 1.2rem;
+    color: #a0a0a0;
+    margin-bottom: 40px;
+}
+
+.features {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 20px;
+    margin-top: 40px;
+}
+
+.feature {
+    background: rgba(255, 255, 255, 0.05);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    border-radius: 12px;
+    padding: 30px;
+    transition: transform 0.2s, box-shadow 0.2s;
+}
+
+.feature:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 10px 40px rgba(0, 217, 255, 0.2);
+}
+
+.feature h3 {
+    font-size: 1.2rem;
+    margin-bottom: 10px;
+    color: #00d9ff;
+}
+
+.feature p {
+    font-size: 0.9rem;
+    margin-bottom: 0;
+}
+
+.feature a {
+    color: #00ff88;
+    text-decoration: none;
+}
+
+.feature a:hover {
+    text-decoration: underline;
+}
+
+code {
+    background: rgba(0, 217, 255, 0.1);
+    padding: 2px 8px;
+    border-radius: 4px;
+    font-family: 'Monaco', 'Menlo', monospace;
+    font-size: 0.85em;
+    color: #00d9ff;
+}

package/public/index.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Nexus Framework</title>
+    <link rel="stylesheet" href="/css/style.css">
+</head>
+<body>
+    <div class="container">
+        <h1>🚀 Nexus Framework</h1>
+        <p>Static files are working!</p>
+        
+        <div class="features">
+            <div class="feature">
+                <h3>📁 Static Files</h3>
+                <p>This page is served from <code>./public/index.html</code></p>
+            </div>
+            
+            <div class="feature">
+                <h3>📚 API Docs</h3>
+                <p><a href="/docs">View Swagger Documentation</a></p>
+            </div>
+            
+            <div class="feature">
+                <h3>🎮 Playground</h3>
+                <p><a href="/playground">Try the API Playground</a></p>
+            </div>
+        </div>
+    </div>
+    
+    <script src="/js/app.js"></script>
+</body>
+</html>

package/public/js/app.js

@@ -0,0 +1,27 @@
+// Nexus Framework - Sample JavaScript
+
+console.log('🚀 Nexus Framework - Static files loaded!');
+
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('Page ready!');
+    
+    // Add some interactivity
+    const features = document.querySelectorAll('.feature');
+    features.forEach((feature, index) => {
+        feature.style.animationDelay = `${index * 0.1}s`;
+        feature.classList.add('fade-in');
+    });
+});
+
+// Add fade-in animation
+const style = document.createElement('style');
+style.textContent = `
+    @keyframes fadeIn {
+        from { opacity: 0; transform: translateY(20px); }
+        to { opacity: 1; transform: translateY(0); }
+    }
+    .fade-in {
+        animation: fadeIn 0.5s ease forwards;
+    }
+`;
+document.head.appendChild(style);

package/src/advanced/cache/InMemoryCacheStore.ts

@@ -0,0 +1,68 @@
+import { EventEmitter } from 'events';
+import { CacheStore, CacheEntry } from './types';
+
+/**
+ * Simple in-memory cache store with TTL support
+ */
+
+export class InMemoryCacheStore<Value = unknown> implements CacheStore<Value> {
+    readonly name: string;
+    private store: Map<string, CacheEntry<Value>> = new Map();
+    private emitter = new EventEmitter();
+    private maxSize: number;
+
+    constructor(name: string, maxSize: number = 10000) {
+        this.name = name;
+        this.maxSize = maxSize;
+    }
+
+    async get(key: string): Promise<CacheEntry<Value> | undefined> {
+        const entry = this.store.get(key);
+        if (!entry) {
+            return undefined;
+        }
+
+        if (entry.expiresAt && entry.expiresAt < Date.now()) {
+            await this.delete(key);
+            return undefined;
+        }
+
+        return entry;
+    }
+
+    async set(key: string, entry: CacheEntry<Value>): Promise<void> {
+        if (this.store.size >= this.maxSize) {
+            const oldestKey = this.store.keys().next().value;
+            if (oldestKey) {
+                this.store.delete(oldestKey);
+            }
+        }
+
+        this.store.set(key, entry);
+        this.emitter.emit('set', key, entry);
+    }
+
+    async delete(key: string): Promise<void> {
+        if (this.store.has(key)) {
+            this.store.delete(key);
+            this.emitter.emit('delete', key);
+        }
+    }
+
+    async clear(): Promise<void> {
+        this.store.clear();
+        this.emitter.emit('clear');
+    }
+
+    async keys(pattern?: RegExp): Promise<string[]> {
+        const allKeys = Array.from(this.store.keys());
+        if (!pattern) {
+            return allKeys;
+        }
+        return allKeys.filter(key => pattern.test(key));
+    }
+
+    on(event: 'set' | 'delete' | 'clear', listener: (...args: any[]) => void) {
+        this.emitter.on(event, listener);
+    }
+}

package/src/advanced/cache/MultiTierCache.ts

@@ -0,0 +1,194 @@
+import { CacheTierConfig, TagIndexEntry, CacheSetOptions, CacheEntry, CacheWrapOptions, MemoizeOptions } from './types';
+
+/**
+ * Multi-tier cache orchestrator
+ */
+
+export class MultiTierCache<Value = unknown> {
+    private tiers: CacheTierConfig<Value>[];
+    private tagIndex: Map<string, TagIndexEntry> = new Map();
+    private defaultTTL: number;
+
+    constructor(tiers: CacheTierConfig<Value>[], defaultTTL: number = 60000) {
+        if (tiers.length === 0) {
+            throw new Error('MultiTierCache requires at least one tier');
+        }
+        this.tiers = tiers;
+        this.defaultTTL = defaultTTL;
+    }
+
+    /**
+     * Retrieve a value from the tiers starting from the fastest one
+     */
+    async get(key: string): Promise<Value | undefined> {
+        for (let i = 0; i < this.tiers.length; i++) {
+            const tier = this.tiers[i];
+            const entry = await tier.store.get(key);
+            if (entry) {
+                if (i > 0) {
+                    // hydrate higher tiers for faster access next time
+                    await this.promoteToHigherTiers(key, entry, i);
+                }
+                return entry.value;
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Set a cache value across tiers
+     */
+    async set(key: string, value: Value, options: CacheSetOptions<Value> = {}): Promise<void> {
+        const expiresAt = this.calculateExpiry(options.ttl);
+        const entry: CacheEntry<Value> = {
+            value,
+            expiresAt,
+            tags: options.tags,
+            meta: options.meta
+        };
+
+        await Promise.all(this.tiers.map(async (tier) => {
+            const ttl = tier.ttl ?? options.ttl ?? this.defaultTTL;
+            const tierEntry = {
+                ...entry,
+                expiresAt: this.calculateExpiry(ttl)
+            };
+            await tier.store.set(key, tierEntry);
+        }));
+
+        if (options.tags?.length) {
+            this.indexTags(key, options.tags, expiresAt);
+        }
+    }
+
+    /**
+     * Delete a cache key from all tiers
+     */
+    async delete(key: string): Promise<void> {
+        await Promise.all(this.tiers.map(tier => tier.store.delete(key)));
+        for (const entry of this.tagIndex.values()) {
+            entry.keys.delete(key);
+        }
+    }
+
+    /**
+     * Delete keys matching a wildcard pattern
+     */
+    async deletePattern(pattern: string): Promise<void> {
+        const regex = new RegExp(
+            '^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+        );
+
+        for (const tier of this.tiers) {
+            const keys = tier.store.keys ? await tier.store.keys(regex) : [];
+            await Promise.all(keys.map(key => tier.store.delete(key)));
+        }
+
+        for (const entry of this.tagIndex.values()) {
+            for (const key of Array.from(entry.keys)) {
+                if (regex.test(key)) {
+                    entry.keys.delete(key);
+                }
+            }
+        }
+    }
+
+    /**
+     * Invalidate cache entries by tags
+     */
+    async invalidateTags(tags: string[]): Promise<void> {
+        const keysToDelete = new Set<string>();
+
+        for (const tag of tags) {
+            const entry = this.tagIndex.get(tag);
+            if (!entry) continue;
+
+            for (const key of entry.keys) {
+                keysToDelete.add(key);
+            }
+            this.tagIndex.delete(tag);
+        }
+
+        await Promise.all(Array.from(keysToDelete).map(key => this.delete(key)));
+    }
+
+    /**
+     * Wrap helper for cache-aside pattern
+     */
+    async wrap(
+        key: string,
+        resolver: () => Promise<Value>,
+        options: CacheWrapOptions<Value> = {}
+    ): Promise<Value> {
+        if (!options.refresh) {
+            const cached = await this.get(key);
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
+
+        const value = await resolver();
+        await this.set(key, value, options);
+        return value;
+    }
+
+    /**
+     * Memoize async functions
+     */
+    memoize<Func extends (...args: any[]) => Promise<Value>>(
+        fn: Func,
+        options: MemoizeOptions<Value> = {}
+    ): (...args: Parameters<Func>) => Promise<Value> {
+        const resolver = options.keyResolver || ((...args: any[]) => JSON.stringify(args));
+
+        return async (...args: Parameters<Func>): Promise<Value> => {
+            const key = resolver(...args);
+            return this.wrap(key, () => fn(...args), options);
+        };
+    }
+
+    /**
+     * Promote cache entry to higher tiers after a miss
+     */
+    private async promoteToHigherTiers(
+        key: string,
+        entry: CacheEntry<Value>,
+        fromIndex: number
+    ): Promise<void> {
+        const tiersToHydrate = this.tiers.slice(0, fromIndex);
+
+        await Promise.all(
+            tiersToHydrate.map(tier => tier.store.set(key, entry))
+        );
+    }
+
+    private calculateExpiry(ttl?: number): number | undefined {
+        if (!ttl) {
+            return undefined;
+        }
+        return Date.now() + ttl;
+    }
+
+    private indexTags(key: string, tags: string[], expiresAt?: number) {
+        for (const tag of tags) {
+            const entry = this.tagIndex.get(tag) || { keys: new Set<string>(), expiresAt };
+            entry.keys.add(key);
+            if (expiresAt) {
+                entry.expiresAt = expiresAt;
+            }
+            this.tagIndex.set(tag, entry);
+        }
+    }
+
+    /**
+     * Export current metrics for observability or admin UI
+     */
+    getStats() {
+        return {
+            tiers: this.tiers.map(tier => ({ name: tier.store.name })),
+            tags: Array.from(this.tagIndex.keys()),
+            defaultTTL: this.defaultTTL
+        };
+    }
+}