zyket 1.2.6 → 1.2.8

package/bin/cli.js

@@ -2,6 +2,7 @@
 const prompts = require('prompts');
 const fs = require('fs');
 const path = require('path');
+const { spawn } = require('child_process');
 const TemplateManager = require('../src/services/template-manager');
 const EnvManager = require('../src/utils/EnvManager');
 const templateManager = new TemplateManager();
@@ -63,11 +64,44 @@ const templateManager = new TemplateManager();
 			console.log('[ZYKET] Creating .env file...');
 			EnvManager.createEnvFile(envPath);
 
+			// Install default backend template files (src and config)
+			console.log('[ZYKET] Installing default backend template files...');
+			const defaultTemplate = templateManager.getTemplate('default');
+			const backendFiles = defaultTemplate.filter(file => {
+				const route = file.route;
+				// Only install src and config files, not frontend
+				// Skip guards and handlers folders since socket is disabled by default
+				return (route.startsWith('default/src/') || route.startsWith('default/config/')) 
+					&& !route.startsWith('default/src/guards/')
+					&& !route.startsWith('default/src/handlers/');
+			});
+
+			for (const file of backendFiles) {
+				const fileName = file.route.split('/').slice(1).join('/');
+				const fileLocation = path.join(process.cwd(), fileName);
+				const folderLocation = path.dirname(fileLocation);
+				
+				// Create directory if it doesn't exist
+				if (!fs.existsSync(folderLocation)) {
+					fs.mkdirSync(folderLocation, { recursive: true });
+				}
+				
+				// Write file if it doesn't exist
+				if (!fs.existsSync(fileLocation)) {
+					fs.writeFileSync(fileLocation, file.content);
+				}
+			}
+			console.log('[ZYKET] ✅ Backend template files installed');
+
 			// Create index.js with boilerplate code
 			console.log('[ZYKET] Creating index.js...');
 			const indexContent = `const { Kernel } = require('zyket');
 
-const kernel = new Kernel();
+const kernel = new Kernel({
+	services: [
+		['auth', require('./src/services/auth'), ["@service_container"]],
+	]
+});
 
 kernel.boot().then(() => {
     console.log('Kernel booted successfully!');
@@ -99,11 +133,41 @@ kernel.boot().then(() => {
 			}
 
 			console.log('\n[ZYKET] ✅ Project initialized successfully!');
-			console.log('\n[ZYKET] Next steps:');
-			console.log('  1. Review and update your .env file');
-			console.log('  2. Run: npm install (if you haven\'t already)');
-			console.log('  3. Run: npm run dev');
-			console.log('\n[ZYKET] Happy coding! 🚀\n');
+
+			// Install dependencies automatically
+			console.log('\n[ZYKET] Installing dependencies...');
+			await new Promise((resolve, reject) => {
+				const npmInstall = spawn('npm', ['install'], {
+					cwd: process.cwd(),
+					stdio: 'inherit',
+					shell: true
+				});
+
+				npmInstall.on('close', (code) => {
+					if (code === 0) {
+						console.log('\n[ZYKET] ✅ Dependencies installed successfully!');
+						resolve();
+					} else {
+						reject(new Error(`npm install exited with code ${code}`));
+					}
+				});
+
+				npmInstall.on('error', (error) => {
+					reject(error);
+				});
+			});
+
+			// Start the project automatically
+			console.log('\n[ZYKET] Starting project...\n');
+			const nodeStart = spawn('node', ['index.js'], {
+				cwd: process.cwd(),
+				stdio: 'inherit',
+				shell: true
+			});
+
+			nodeStart.on('error', (error) => {
+				console.error('[ZYKET] Error starting project:', error);
+			});
 		},
 		'install-template': async () => {
 			const templates = templateManager.getTemplates();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyket",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/services/cache/index.js

@@ -3,36 +3,93 @@ const { createClient } = require("redis");
 
 module.exports = class Cache extends Service {
   #container;
-  client;
+  #client;
+  #useRedis;
+  #memoryCache;
+  #expirations;
 
   constructor(container, url) {
     super("cache");
     this.#container = container;
-    this.client = createClient({ url });
+    this.#useRedis = !!url && url !== '';
+    
+    if (this.#useRedis) {
+      this.#client = createClient({ url });
+    } else {
+      // Use in-memory cache
+      this.#memoryCache = new Map();
+      this.#expirations = new Map();
+    }
   }
 
   async boot() {
-    await this.client.connect();
+    if (this.#useRedis) {
+      await this.#client.connect();
+      this.#container.get('logger').info('Cache service using Redis');
+    } else {
+      this.#container.get('logger').info('Cache service using in-memory cache');
+    }
   }
 
   async set(key, value) {
-    return await this.client.set(key, value);
-    
+    if (this.#useRedis) {
+      return await this.#client.set(key, value);
+    } else {
+      this.#memoryCache.set(key, value);
+      return 'OK';
+    }
   }
 
   async get(key) {
-    return await this.client.get(key);
+    if (this.#useRedis) {
+      return await this.#client.get(key);
+    } else {
+      // Check if the key has expired
+      if (this.#expirations.has(key)) {
+        const expireTime = this.#expirations.get(key);
+        if (Date.now() > expireTime) {
+          this.#memoryCache.delete(key);
+          this.#expirations.delete(key);
+          return null;
+        }
+      }
+      return this.#memoryCache.get(key) || null;
+    }
   }
 
   async del(key) {
-    return await this.client.del(key);
+    if (this.#useRedis) {
+      return await this.#client.del(key);
+    } else {
+      this.#expirations.delete(key);
+      return this.#memoryCache.delete(key) ? 1 : 0;
+    }
   }
 
   async keys(pattern) {
-    return await this.client.keys(pattern);
+    if (this.#useRedis) {
+      return await this.#client.keys(pattern);
+    } else {
+      // Simple pattern matching for memory cache
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+      return Array.from(this.#memoryCache.keys()).filter(key => regex.test(key));
+    }
   }
 
   async expire(key, seconds) {
-    return await this.client.expire(key, seconds);
+    if (this.#useRedis) {
+      return await this.#client.expire(key, seconds);
+    } else {
+      if (this.#memoryCache.has(key)) {
+        const expireTime = Date.now() + (seconds * 1000);
+        this.#expirations.set(key, expireTime);
+        return 1;
+      }
+      return 0;
+    }
+  }
+
+  get client() {
+    return this.#useRedis ? this.#client : null;
   }
 }

package/src/templates/default/src/services/auth/auth.js

@@ -0,0 +1,8 @@
+const AuthService = require('./index.js');
+
+const auth = new AuthService({
+  get: (serviceName) => {
+  }
+});
+
+module.exports = auth.auth;

package/src/templates/default/src/services/auth/index.js

@@ -0,0 +1,33 @@
+const { AuthService } = require('zyket');
+
+module.exports = class CustomAuthService extends AuthService {
+  #container;
+  client;
+
+  constructor(container) {
+    super(container);
+    this.#container = container;
+  }
+
+  get userAdditionalFields() {
+  }
+
+  get organizationAdditionalFields() {
+  }
+
+  async sendResetPasswordEmail({ user, url, token }, request) {
+    throw new Error("sendResetPasswordEmail method not implemented");
+  }
+
+  async sendVerificationEmail({ user, url, token }, request) {
+    throw new Error("sendVerificationEmail method not implemented");
+  }
+
+  async sendInvitationEmail(data) {
+    throw new Error("sendInvitationEmail method not implemented");
+  }
+
+  async allowUserToCreateOrganization(user) {
+    throw new Error("allowUserToCreateOrganization method not implemented");
+  }
+}

package/src/utils/EnvManager.js

@@ -12,6 +12,10 @@ module.exports = class EnvManager {
   }
 
   static getDefaultSecrets() {
+    const header = `# Zyket Environment Configuration
+# Leave CACHE_URL empty to use in-memory cache, or set to redis://localhost:6379 for Redis
+
+`;
     const envsToCreate = {
       DEBUG: true,
       PORT: 3000,
@@ -35,7 +39,7 @@ module.exports = class EnvManager {
       DISABLE_VITE: true,
     }
 
-    return Object.entries(envsToCreate).reduce((acc, [key, value]) => {
+    return header + Object.entries(envsToCreate).reduce((acc, [key, value]) => {
       return `${acc}${key}=${value}\n`;
     }, "");
   }