vasuzex 2.0.13 → 2.0.15

package/framework/Console/templates/api/server.js.hbs

@@ -0,0 +1,127 @@
+/**
+ * {{capitalize appName}} Server
+ * Extends BaseServer from framework with database support
+ */
+
+import { BaseServer, Facade } from 'vasuzex';
+import dotenv from 'dotenv';
+import guruorm from 'guruorm';
+const { Capsule } = guruorm;
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createApp as buildApp } from './app.js';
+
+// Load root .env file BEFORE anything else
+const projectRoot = process.cwd();
+dotenv.config({ path: `${projectRoot}/.env` });
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * {{pascalCase appName}}Server - Extends BaseServer
+ */
+class {{pascalCase appName}}Server extends BaseServer {
+  constructor() {
+    super({
+      appName: process.env.APP_NAME || '{{appName}}-api',
+      projectRoot: projectRoot
+    });
+    
+    this.db = null;
+  }
+
+  /**
+   * Validate configuration
+   */
+  validateConfig() {
+    // Add your custom config validations here
+    super.validateConfig();
+  }
+
+  /**
+   * Initialize database connection
+   */
+  async initializeDatabase() {
+    try {
+      // Use root config (centralized)
+      const dbUrl = process.env.DATABASE_URL || 'postgresql://postgres@localhost:5432/{{appName}}_db';
+      
+      // Create capsule instance (GuruORM)
+      const capsule = new Capsule();
+      
+      // Add PostgreSQL connection
+      capsule.addConnection({
+        driver: 'pgsql',
+        host: process.env.POSTGRES_HOST || 'localhost',
+        port: parseInt(process.env.POSTGRES_PORT) || 5432,
+        database: process.env.POSTGRES_DB || '{{appName}}_db',
+        username: process.env.POSTGRES_USER || 'postgres',
+        password: process.env.POSTGRES_PASSWORD || '',
+        charset: 'utf8',
+        prefix: '',
+        schema: 'public',
+      });
+      
+      // Make capsule globally available
+      capsule.setAsGlobal();
+      capsule.bootEloquent();
+      
+      // Get DB connection for Facade
+      this.db = capsule.connection();
+      
+      console.log('[{{capitalize appName}}API] 🗄️  Database connected');
+      
+      return this.db;
+    } catch (error) {
+      console.error('[{{capitalize appName}}API] ❌ Database error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Initialize {{appName}}-specific services
+   */
+  async initializeServices() {
+    try {
+      // Add your service initializations here
+      console.log('[{{capitalize appName}}API] 📦 Services initialized');
+    } catch (error) {
+      console.error('[{{capitalize appName}}API] ❌ Services error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Create Express app
+   */
+  createApp() {
+    return buildApp();
+  }
+
+  /**
+   * Custom startup tasks
+   */
+  async onServerStart(server) {
+    const port = process.env.APP_PORT || 3000;
+    console.log(`🚀 {{appName}}-api running on http://localhost:${port}`);
+  }
+}
+
+/**
+ * Bootstrap and start server
+ */
+async function bootstrap() {
+  try {
+    const server = new {{pascalCase appName}}Server();
+    await server.initializeDatabase();
+    await server.initializeServices();
+    await server.start();
+  } catch (error) {
+    console.error('❌ Failed to start server:', error);
+    process.exit(1);
+  }
+}
+
+// Start server
+bootstrap();

package/framework/Console/templates/api/services/AuthService.js.hbs

@@ -0,0 +1,95 @@
+/**
+ * Authentication Service
+ * Business logic for authentication
+ */
+
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import { User } from '@{{projectName}}/database';
+
+export class AuthService {
+  /**
+   * Register a new user
+   */
+  async register(data) {
+    // Check if user already exists
+    const existingUser = await User.findByEmail(data.email);
+    if (existingUser) {
+      throw new Error('User already exists with this email');
+    }
+
+    // Hash password
+    const hashedPassword = await bcrypt.hash(data.password, 10);
+
+    // Create user
+    const user = await User.create({
+      name: data.name,
+      email: data.email,
+      password: hashedPassword,
+    });
+
+    // Generate token
+    const token = this.generateToken(user);
+
+    // Remove password from response
+    delete user.password;
+
+    return {
+      user,
+      token,
+    };
+  }
+
+  /**
+   * Login user
+   */
+  async login(email, password) {
+    // Find user
+    const user = await User.findByEmail(email);
+    if (!user) {
+      throw new Error('Invalid credentials');
+    }
+
+    // Verify password
+    const isValid = await bcrypt.compare(password, user.password);
+    if (!isValid) {
+      throw new Error('Invalid credentials');
+    }
+
+    // Generate token
+    const token = this.generateToken(user);
+
+    // Remove password from response
+    delete user.password;
+
+    return {
+      user,
+      token,
+    };
+  }
+
+  /**
+   * Generate JWT token
+   */
+  generateToken(user) {
+    return jwt.sign(
+      { 
+        id: user.id, 
+        email: user.email 
+      },
+      process.env.JWT_SECRET || 'secret',
+      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
+    );
+  }
+
+  /**
+   * Verify JWT token
+   */
+  verifyToken(token) {
+    try {
+      return jwt.verify(token, process.env.JWT_SECRET || 'secret');
+    } catch (error) {
+      throw new Error('Invalid token');
+    }
+  }
+}

package/framework/Database/Model.js

@@ -331,7 +331,7 @@ export class Model extends GuruORMModel {
   }
 
   /**
-   * Perform insert
+   * Perform insert operation
    */
   async performInsert() {
     // Fire creating event
@@ -344,13 +344,16 @@ export class Model extends GuruORMModel {
       this.updateTimestamps();
     }
 
+    // Filter out internal tracking properties before insert
     const attributes = { ...this.attributes };
+    delete attributes.isDirtyFlag;  // Remove internal tracking fields
     
-    // Use GuruORM's insert
-    const result = await this.constructor.insert(attributes);
+    // Use query builder with explicit table - should handle reserved keywords
+    const tableName = this.constructor.tableName || this.constructor.table;
+    const result = await this.constructor.query().table(tableName).insert(attributes);
 
     // Set primary key if auto-incrementing
-    if (this.constructor.incrementing !== false) {
+    if (this.constructor.incrementing !== false && result) {
       const pk = this.constructor.primaryKey || 'id';
       this.setAttribute(pk, result.insertId || result[0] || attributes[pk]);
     }
@@ -612,6 +615,57 @@ export class Model extends GuruORMModel {
     return instance;
   }
 
+  /**
+   * Insert new record (static method for performInsert)
+   * Returns the insert result from query builder
+   */
+  static async insert(attributes) {
+    // Use query builder - must use column quoting for reserved words like "password"
+    const query = this.query();
+    
+    // GuruORM's query builder should handle this, but if not, wrap in try-catch
+    try {
+      const result = await query.insert(attributes);
+      return result;
+    } catch (error) {
+      // If it's a reserved word error, try with explicit column mapping
+      console.error('Insert error:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Update records matching conditions (static method for performUpdate)
+   */
+  static async updateWhere(conditions, attributes) {
+    const query = this.query();
+    
+    // Apply conditions
+    for (const [key, value] of Object.entries(conditions)) {
+      query.where(key, value);
+    }
+    
+    return await query.update(attributes);
+  }
+
+  /**
+   * Delete records by primary key (static method)
+   */
+  static async destroy(id) {
+    const pk = this.primaryKey || 'id';
+    const query = this.query();
+    
+    if (this.softDeletes) {
+      // Soft delete
+      return await query.where(pk, id).update({
+        [this.deletedAt]: new Date()
+      });
+    } else {
+      // Hard delete
+      return await query.where(pk, id).delete();
+    }
+  }
+
   /**
    * Find by primary key (override GuruORM's find)
    */

package/framework/Foundation/BaseApp.js

@@ -1,3 +1,4 @@
+import express from 'express';
 import { Application } from './Application.js';
 import { applySecurityMiddleware } from '../Http/Middleware/SecurityMiddleware.js';
 
@@ -14,6 +15,7 @@ export class BaseApp extends Application {
     this.serviceName = options.serviceName || options.appName || 'app';
     this.appName = options.appName;
     this.appType = options.appType;
+    this.corsOrigin = options.corsOrigin; // Store CORS origin for security middleware
     this.middlewareSetup = false;
     this.routesSetup = false;
     this.securitySetup = false;
@@ -39,6 +41,9 @@ export class BaseApp extends Application {
       this.securitySetup = true;
     }
 
+    // Setup core body parsing middleware (required for API)
+    this.setupBodyParsing();
+
     // Setup custom middleware
     if (!this.middlewareSetup) {
       this.setupCustomMiddleware();
@@ -72,7 +77,31 @@ export class BaseApp extends Application {
   setupSecurityMiddleware() {
     try {
       // Get security configuration (may not exist in test environment)
-      const securityConfig = this.has('config') ? this.config('security', {}) : {};
+      let securityConfig = this.has('config') ? this.config('security', {}) : {};
+      
+      // If no config exists but corsOrigin is provided, create minimal CORS config
+      if (this.corsOrigin && (!securityConfig || Object.keys(securityConfig).length === 0)) {
+        securityConfig = {
+          helmet: false, // Disable helmet if no config
+          cors: {
+            origin: this.corsOrigin,
+            credentials: true,
+            methods: ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE', 'OPTIONS'],
+            allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With', 'Accept', 'Origin'],
+            exposedHeaders: ['X-Total-Count', 'X-Page-Count'],
+            maxAge: 86400,
+            preflightContinue: false,
+            optionsSuccessStatus: 204
+          },
+          csrf: { enabled: false } // Disable CSRF by default for API
+        };
+      } else if (this.corsOrigin && securityConfig.cors) {
+        // Override CORS origin if config exists
+        securityConfig.cors = {
+          ...securityConfig.cors,
+          origin: this.corsOrigin
+        };
+      }
       
       // Only apply if configuration exists and not explicitly disabled
       if (securityConfig && Object.keys(securityConfig).length > 0) {
@@ -84,6 +113,18 @@ export class BaseApp extends Application {
     }
   }
 
+  /**
+   * Setup body parsing middleware
+   * Core middleware for parsing JSON and URL-encoded request bodies
+   */
+  setupBodyParsing() {
+    // Parse JSON request bodies
+    this.express.use(express.json());
+    
+    // Parse URL-encoded request bodies (forms)
+    this.express.use(express.urlencoded({ extended: true }));
+  }
+
   /**
    * Register a route
    */

package/framework/package.json

@@ -12,5 +12,8 @@
   "imports": {
     "#framework": "./index.js",
     "#framework/*": "./*"
+  },
+  "devDependencies": {
+    "plop": "^4.0.1"
   }
 }

package/frontend/react-ui/node_modules/@esbuild/darwin-x64/README.md

@@ -0,0 +1,3 @@
+# esbuild
+
+This is the macOS 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details.

package/frontend/react-ui/node_modules/@esbuild/darwin-x64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@esbuild/darwin-x64",
+  "version": "0.25.12",
+  "description": "The macOS 64-bit binary for esbuild, a JavaScript bundler.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evanw/esbuild.git"
+  },
+  "license": "MIT",
+  "preferUnplugged": true,
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

package/frontend/react-ui/node_modules/esbuild/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Evan Wallace
+
+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/frontend/react-ui/node_modules/esbuild/README.md

@@ -0,0 +1,3 @@
+# esbuild
+
+This is a JavaScript bundler and minifier. See https://github.com/evanw/esbuild and the [JavaScript API documentation](https://esbuild.github.io/api/) for details.

package/frontend/react-ui/node_modules/esbuild/bin/esbuild

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var packageDarwin_arm64 = "@esbuild/darwin-arm64";
+var packageDarwin_x64 = "@esbuild/darwin-x64";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd arm64 LE": "@esbuild/netbsd-arm64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd arm64 LE": "@esbuild/openbsd-arm64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64",
+  "openharmony arm64 LE": "@esbuild/openharmony-arm64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM2 = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM2 = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM: isWASM2 };
+}
+function pkgForSomeOtherPlatform() {
+  const libMainJS = require.resolve("esbuild");
+  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
+  if (path.basename(nodeModulesDirectory) === "node_modules") {
+    for (const unixKey in knownUnixlikePackages) {
+      try {
+        const pkg = knownUnixlikePackages[unixKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+    for (const windowsKey in knownWindowsPackages) {
+      try {
+        const pkg = knownWindowsPackages[windowsKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+function generateBinPath() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    }
+  }
+  const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform();
+  let binPath2;
+  try {
+    binPath2 = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    binPath2 = downloadedBinPath(pkg, subpath);
+    if (!fs.existsSync(binPath2)) {
+      try {
+        require.resolve(pkg);
+      } catch {
+        const otherPkg = pkgForSomeOtherPlatform();
+        if (otherPkg) {
+          let suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild on Windows or macOS and copying "node_modules"
+into a Docker image that runs Linux, or by copying "node_modules" between
+Windows and WSL environments.
+
+If you are installing with npm, you can try not copying the "node_modules"
+directory when you copy the files over, and running "npm ci" or "npm install"
+on the destination platform after the copy. Or you could consider using yarn
+instead of npm which has built-in support for installing a package on multiple
+platforms simultaneously.
+
+If you are installing with yarn, you can try listing both this platform and the
+other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
+feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
+            suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild with npm running inside of Rosetta 2 and then
+trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
+2 is Apple's on-the-fly x86_64-to-arm64 translation service).
+
+If you are installing with npm, you can try ensuring that both npm and node are
+not running under Rosetta 2 and then reinstalling esbuild. This likely involves
+changing how you installed npm and/or node. For example, installing node with
+the universal installer here should work: https://nodejs.org/en/download/. Or
+you could consider using yarn instead of npm which has built-in support for
+installing a package on multiple platforms simultaneously.
+
+If you are installing with yarn, you can try listing both "arm64" and "x64"
+in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
+https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          }
+          throw new Error(`
+You installed esbuild for another platform than the one you're currently using.
+This won't work because esbuild is written with native code and needs to
+install a platform-specific binary executable.
+${suggestions}
+Another alternative is to use the "esbuild-wasm" package instead, which works
+the same way on all platforms. But it comes with a heavy performance cost and
+can sometimes be 10x slower than the "esbuild" package, so you may also not
+want to do that.
+`);
+        }
+        throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
+
+If you are installing esbuild with npm, make sure that you don't specify the
+"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
+of "package.json" is used by esbuild to install the correct binary executable
+for your current platform.`);
+      }
+      throw e;
+    }
+  }
+  if (/\.zip\//.test(binPath2)) {
+    let pnpapi;
+    try {
+      pnpapi = require("pnpapi");
+    } catch (e) {
+    }
+    if (pnpapi) {
+      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
+      const binTargetPath = path.join(
+        root,
+        "node_modules",
+        ".cache",
+        "esbuild",
+        `pnpapi-${pkg.replace("/", "-")}-${"0.25.12"}-${path.basename(subpath)}`
+      );
+      if (!fs.existsSync(binTargetPath)) {
+        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
+        fs.copyFileSync(binPath2, binTargetPath);
+        fs.chmodSync(binTargetPath, 493);
+      }
+      return { binPath: binTargetPath, isWASM: isWASM2 };
+    }
+  }
+  return { binPath: binPath2, isWASM: isWASM2 };
+}
+
+// lib/npm/node-shim.ts
+var { binPath, isWASM } = generateBinPath();
+if (isWASM) {
+  require("child_process").execFileSync("node", [binPath].concat(process.argv.slice(2)), { stdio: "inherit" });
+} else {
+  require("child_process").execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+}