webspresso 0.0.17 → 0.0.19

package/README.md

@@ -808,13 +808,16 @@ const User = defineModel({
   scopes: { softDelete: true, timestamps: true },
 });
 
-// 4. Create database and use
+// 4. Create database (models auto-loaded from ./models directory)
 const db = createDatabase({
   client: 'pg',
   connection: process.env.DATABASE_URL,
+  models: './models', // Optional, defaults to './models'
 });
 
-const UserRepo = db.createRepository(User);
+// Models are automatically loaded from models/ directory
+// Use getRepository with model name
+const UserRepo = db.getRepository('User');
 const user = await UserRepo.findById(1, { with: ['company', 'posts'] });
 ```
 
@@ -880,11 +883,48 @@ const User = defineModel({
 });
 ```
 
+### Auto-Loading Models
+
+Models are automatically loaded from the `models/` directory when you create a database instance:
+
+```javascript
+// models/User.js
+const { defineModel, zdb } = require('webspresso');
+
+module.exports = defineModel({
+  name: 'User',
+  table: 'users',
+  schema: zdb.schema({
+    id: zdb.id(),
+    email: zdb.string({ unique: true }),
+    name: zdb.string(),
+    created_at: zdb.timestamp({ auto: 'create' }),
+    updated_at: zdb.timestamp({ auto: 'update' }),
+  }),
+});
+
+// In your application code
+const db = createDatabase({
+  client: 'pg',
+  connection: process.env.DATABASE_URL,
+  models: './models', // Optional, defaults to './models'
+});
+
+// Models are automatically loaded, use getRepository with model name
+const UserRepo = db.getRepository('User');
+```
+
+**Model File Structure:**
+- Place model files in `models/` directory (or custom path via `config.models`)
+- Each file should export a model defined with `defineModel()`
+- Files starting with `_` are ignored (useful for shared utilities)
+- Models are loaded in alphabetical order
+
 ### Repository API
 
 ```javascript
 const db = createDatabase({ client: 'pg', connection: '...' });
-const UserRepo = db.createRepository(User);
+const UserRepo = db.getRepository('User'); // Use model name string
 
 // Find by ID (with eager loading)
 const user = await UserRepo.findById(1, { with: ['company', 'posts'] });
@@ -974,8 +1014,8 @@ await UserRepo.query().forTenant(tenantId).list();
 
 ```javascript
 await db.transaction(async (trx) => {
-  const userRepo = trx.createRepository(User);
-  const postRepo = trx.createRepository(Post);
+  const userRepo = trx.getRepository('User'); // Use model name
+  const postRepo = trx.getRepository('Post');
   
   const user = await userRepo.create({ email: 'new@test.com', name: 'New' });
   await postRepo.create({ title: 'First Post', user_id: user.id });

package/bin/commands/dev.js

@@ -6,6 +6,26 @@
 const fs = require('fs');
 const { spawn } = require('child_process');
 
+/**
+ * Build node --watch arguments with additional watch paths
+ * @returns {string[]} Node arguments
+ */
+function buildWatchArgs() {
+  const args = ['--watch'];
+  
+  // Add watch paths for common directories
+  const watchPaths = ['pages', 'models', 'views'];
+  
+  for (const dir of watchPaths) {
+    if (fs.existsSync(dir)) {
+      args.push(`--watch-path=./${dir}`);
+    }
+  }
+  
+  args.push('server.js');
+  return args;
+}
+
 function registerCommand(program) {
   program
     .command('dev')
@@ -24,9 +44,13 @@ function registerCommand(program) {
       const hasTailwind = fs.existsSync('tailwind.config.js') && fs.existsSync('src/input.css');
       const shouldWatchCss = hasTailwind && options.css !== false;
       
+      // Build watch arguments
+      const watchArgs = buildWatchArgs();
+      const watchDirs = watchArgs.filter(a => a.startsWith('--watch-path')).map(a => a.split('=')[1]);
+      
       if (shouldWatchCss) {
         console.log(`\n🚀 Starting development server on port ${options.port}...`);
-        console.log('   Watching CSS and server files...\n');
+        console.log(`   Watching: server.js${watchDirs.length ? ', ' + watchDirs.join(', ') : ''}, CSS\n`);
         
         // Start CSS watch
         const cssWatch = spawn('npm', ['run', 'watch:css'], {
@@ -34,8 +58,8 @@ function registerCommand(program) {
           shell: true
         });
         
-        // Start server
-        const server = spawn('node', ['--watch', 'server.js'], {
+        // Start server with watch paths
+        const server = spawn('node', watchArgs, {
           stdio: 'inherit',
           shell: true,
           env: { ...process.env, PORT: options.port, NODE_ENV: 'development' }
@@ -54,10 +78,10 @@ function registerCommand(program) {
         cssWatch.on('exit', cleanup);
         server.on('exit', cleanup);
       } else {
-        console.log(`\n🚀 Starting development server on port ${options.port}...\n`);
+        console.log(`\n🚀 Starting development server on port ${options.port}...`);
+        console.log(`   Watching: server.js${watchDirs.length ? ', ' + watchDirs.join(', ') : ''}\n`);
         
-        const { spawn } = require('child_process');
-        const child = spawn('node', ['--watch', 'server.js'], {
+        const child = spawn('node', watchArgs, {
           stdio: 'inherit',
           shell: true,
           env: { ...process.env, PORT: options.port, NODE_ENV: 'development' }

package/bin/commands/new.js

@@ -172,7 +172,7 @@ function registerCommand(program) {
         description: 'Webspresso project',
         main: 'server.js',
         scripts: {
-          dev: 'node --watch server.js',
+          dev: 'webspresso dev',
           start: 'NODE_ENV=production node server.js'
         },
         dependencies: {
@@ -545,7 +545,7 @@ module.exports = {
         
         updatedPackageJson.scripts['build:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --minify';
         updatedPackageJson.scripts['watch:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --watch';
-        updatedPackageJson.scripts.dev = 'npm run watch:css & node --watch server.js';
+        updatedPackageJson.scripts.dev = 'webspresso dev';
         updatedPackageJson.scripts.start = 'npm run build:css && NODE_ENV=production node server.js';
         
         fs.writeFileSync(

package/core/orm/index.js

@@ -5,27 +5,13 @@
  */
 
 const path = require('path');
+const fs = require('fs');
 const { createSchemaHelpers, extractColumnsFromSchema, getColumnMeta } = require('./schema-helpers');
 const { defineModel, getModel, getAllModels, hasModel, clearRegistry } = require('./model');
-
-// Create zdb instance with zod (zod is a dependency)
-let z;
-try {
-  z = require('zod');
-} catch {
-  // Zod not installed, zdb will be undefined
-  z = null;
-}
-
-// Export zdb instance directly
-const zdb = z ? createSchemaHelpers(z) : null;
 const { createRepository } = require('./repository');
-const { createQueryBuilder, QueryBuilder } = require('./query-builder');
-const { runTransaction, createTransactionContext } = require('./transaction');
 const { createMigrationManager } = require('./migrations');
-const { scaffoldMigration, scaffoldAlterMigration, scaffoldDropMigration } = require('./migrations/scaffold');
-const { createScopeContext } = require('./scopes');
 const { createSeeder } = require('./seeder');
+const { createScopeContext } = require('./scopes');
 
 /**
  * Create a database instance
@@ -52,74 +38,38 @@ function createDatabase(config) {
     };
     
     const driverName = driverMap[client] || client;
+    const projectNodeModules = path.join(process.cwd(), 'node_modules');
     
-    // Try to resolve and pre-load the driver from project's node_modules
-    // This ensures Knex can find it when it tries to load it
-    let driverPath = null;
-    const resolvePaths = [
-      path.join(process.cwd(), 'node_modules'),
-      process.cwd(),
-    ];
-    
-    // Also try to resolve from parent directories (for nested projects)
-    let currentPath = process.cwd();
-    for (let i = 0; i < 5; i++) {
-      resolvePaths.push(path.join(currentPath, 'node_modules'));
-      const parent = path.dirname(currentPath);
-      if (parent === currentPath) break; // Reached root
-      currentPath = parent;
-    }
-    
-    for (const resolvePath of resolvePaths) {
-      try {
-        driverPath = require.resolve(driverName, { paths: [resolvePath] });
-        // Pre-load the driver so Knex can find it in Module._cache
-        // This is critical: Knex uses require() internally, so we need to
-        // load it into the cache first
-        require(driverPath);
-        break;
-      } catch (e) {
-        // Continue to next path
-      }
-    }
-    
-    // If still not found, try default resolution (might be in webspresso's node_modules)
-    if (!driverPath) {
-      try {
-        // Try to find it anywhere in the module resolution path
-        driverPath = require.resolve(driverName);
-        require(driverPath);
-      } catch (e) {
-        // Driver not found anywhere
-        const installCmd = driverName === 'better-sqlite3' 
-          ? 'npm install better-sqlite3 --save'
-          : driverName === 'pg'
-          ? 'npm install pg --save'
-          : driverName === 'mysql2'
-          ? 'npm install mysql2 --save'
-          : `npm install ${driverName} --save`;
-        
-        throw new Error(
-          `Database driver "${driverName}" is not installed in your project. ` +
-          `Please install it with: ${installCmd}\n` +
-          `Note: Database drivers are peer dependencies and must be installed in your project's node_modules, not globally.\n` +
-          `Current working directory: ${process.cwd()}\n` +
-          `Make sure you run "${installCmd}" in your project directory.`
-        );
-      }
+    // Try to find and pre-load driver from project's node_modules
+    try {
+      const driverPath = require.resolve(driverName, { paths: [projectNodeModules] });
+      require(driverPath); // Pre-load into Module._cache
+    } catch (e) {
+      // Driver not found in project
+      const installCmd = driverName === 'better-sqlite3' 
+        ? 'npm install better-sqlite3 --save'
+        : driverName === 'pg'
+        ? 'npm install pg --save'
+        : driverName === 'mysql2'
+        ? 'npm install mysql2 --save'
+        : `npm install ${driverName} --save`;
+      
+      throw new Error(
+        `Database driver "${driverName}" is not installed in your project.\n` +
+        `Please install it with: ${installCmd}\n` +
+        `Current working directory: ${process.cwd()}`
+      );
     }
   }
 
   // Create Knex instance
-  // Knex will try to load the driver from its own node_modules
-  // We need to ensure the driver is available in the project's node_modules
   let knexInstance;
   try {
     knexInstance = knex(config);
   } catch (e) {
-    // If knex throws an error about missing driver, provide better message
-    if (e.message && (e.message.includes('Cannot find module') || e.message.includes('run') || e.message.includes('npm install'))) {
-      const driverName = config.client;
+    // Provide helpful error message
+    if (e.message && (e.message.includes('Cannot find module') || e.message.includes('npm install'))) {
+      const driverName = driverMap[config.client] || config.client;
       const installCmd = driverName === 'better-sqlite3' 
         ? 'npm install better-sqlite3 --save'
         : driverName === 'pg'
@@ -128,61 +78,10 @@ function createDatabase(config) {
         ? 'npm install mysql2 --save'
         : `npm install ${driverName} --save`;
       
-      // Check if driver exists in project's node_modules
-      let driverExists = false;
-      let foundDriverPath = null;
-      const checkPaths = [
-        path.join(process.cwd(), 'node_modules'),
-        process.cwd(),
-      ];
-      
-      // Also check parent directories
-      let currentPath = process.cwd();
-      for (let i = 0; i < 5; i++) {
-        checkPaths.push(path.join(currentPath, 'node_modules'));
-        const parent = path.dirname(currentPath);
-        if (parent === currentPath) break;
-        currentPath = parent;
-      }
-      
-      for (const checkPath of checkPaths) {
-        try {
-          foundDriverPath = require.resolve(driverName, { paths: [checkPath] });
-          driverExists = true;
-          break;
-        } catch (resolveError) {
-          // Continue checking
-        }
-      }
-      
-      if (!driverExists) {
-        throw new Error(
-          `Database driver "${driverName}" is not installed in your project. ` +
-          `Please install it with: ${installCmd}\n` +
-          `Note: Database drivers are peer dependencies and must be installed in your project's node_modules, not globally.\n` +
-          `Current working directory: ${process.cwd()}\n` +
-          `Make sure you run "${installCmd}" in your project directory.`
-        );
-      } else {
-        // Driver exists but Knex can't find it - try to manually require it
-        try {
-          // Force load the driver into Module._cache
-          require(foundDriverPath);
-          // Retry Knex initialization
-          knexInstance = knex(config);
-        } catch (retryError) {
-          throw new Error(
-            `Database driver "${driverName}" is installed but Knex cannot find it. ` +
-            `This might be a module resolution issue. Try:\n` +
-            `1. Delete node_modules and package-lock.json\n` +
-            `2. Run "npm install" again\n` +
-            `3. Make sure "${driverName}" is in your package.json dependencies\n` +
-            `4. Verify the driver is accessible: node -e "require('${driverName}')"\n` +
-            `Driver found at: ${foundDriverPath}\n` +
-            `Original error: ${e.message}`
-          );
-        }
-      }
+      throw new Error(
+        `Failed to initialize database: ${e.message}\n` +
+        `Make sure "${driverName}" is installed: ${installCmd}`
+      );
     }
     throw e;
   }
@@ -191,115 +90,185 @@ function createDatabase(config) {
   const migrationConfig = config.migrations || {};
   const migrate = createMigrationManager(knexInstance, migrationConfig);
 
-  // Default scope context
-  let globalScopeContext = createScopeContext();
+  // Auto-load models from models directory
+  const modelsDir = config.models || './models';
+  const absoluteModelsDir = path.resolve(process.cwd(), modelsDir);
+  
+  if (fs.existsSync(absoluteModelsDir)) {
+    const modelFiles = fs.readdirSync(absoluteModelsDir)
+      .filter(file => file.endsWith('.js') && !file.startsWith('_'));
+    
+    for (const file of modelFiles) {
+      try {
+        const modelPath = path.join(absoluteModelsDir, file);
+        require(modelPath);
+      } catch (error) {
+        console.error(`Error loading model from ${file}:`, error.message);
+        // Continue loading other models even if one fails
+      }
+    }
+  }
+
+  // Model registry (use global registry, but keep local for backward compatibility)
+  const models = new Map();
+  
+  // Sync global registry to local registry
+  const globalModels = getAllModels();
+  for (const [name, model] of globalModels) {
+    models.set(name, model);
+  }
 
   /**
-   * Set global tenant ID
-   * @param {*} tenantId - Tenant ID
-   * @returns {DatabaseInstance}
+   * Get a model by name
+   * @param {string} name - Model name
+   * @returns {import('./types').ModelDefinition}
    */
-  function forTenant(tenantId) {
-    globalScopeContext.tenantId = tenantId;
-    return db;
+  function getModelInstance(name) {
+    // First check local registry
+    let model = models.get(name);
+    
+    // If not found, check global registry (for models loaded after database creation)
+    if (!model) {
+      model = getModel(name);
+      if (model) {
+        models.set(name, model); // Cache in local registry
+      }
+    }
+    
+    if (!model) {
+      throw new Error(`Model "${name}" is not defined. Make sure you've called defineModel() first or the model file exists in ${modelsDir}.`);
+    }
+    return model;
+  }
+
+  /**
+   * Check if a model exists
+   * @param {string} name - Model name
+   * @returns {boolean}
+   */
+  function hasModelInstance(name) {
+    return models.has(name);
   }
 
   /**
-   * Create a repository for a model
+   * Get all registered models
+   * @returns {Array<import('./types').ModelDefinition>}
+   */
+  function getAllModelInstances() {
+    return Array.from(models.values());
+  }
+
+  /**
+   * Register a model
    * @param {import('./types').ModelDefinition} model - Model definition
+   */
+  function registerModel(model) {
+    models.set(model.name, model);
+    // Also ensure it's in global registry (defineModel already does this, but just in case)
+  }
+
+  /**
+   * Get repository for a model
+   * @param {string} modelName - Model name
+   * @param {import('./types').ScopeContext} [scopeContext] - Scope context
    * @returns {import('./types').Repository}
    */
-  function createRepo(model) {
-    return createRepository(model, knexInstance, { ...globalScopeContext });
+  function getRepository(modelName, scopeContext) {
+    const model = getModelInstance(modelName);
+    // Always create fresh scope context if not provided to avoid shared state
+    const ctx = scopeContext || createScopeContext();
+    return createRepository(model, knexInstance, ctx);
   }
 
   /**
-   * Run a callback within a transaction
-   * @param {function(import('./types').TransactionContext): Promise<*>} callback
-   * @returns {Promise<*>}
+   * Get query builder for a model
+   * @param {string} modelName - Model name
+   * @param {import('./types').ScopeContext} [scopeContext] - Scope context
+   * @returns {import('knex').Knex.QueryBuilder}
    */
-  function transaction(callback) {
-    return runTransaction(knexInstance, callback, { ...globalScopeContext });
+  function query(modelName, scopeContext) {
+    const model = getModelInstance(modelName);
+    const ctx = scopeContext || createScopeContext();
+    const repo = createRepository(model, knexInstance, ctx);
+    return repo.query();
   }
 
   /**
-   * Get raw Knex instance for advanced queries
-   * @returns {import('knex').Knex}
+   * Create seeder instance
+   * @returns {import('./types').Seeder}
    */
-  function raw() {
-    return knexInstance;
+  function createSeederInstance() {
+    return createSeeder(knexInstance, models);
   }
 
   /**
-   * Close all database connections
-   * @returns {Promise<void>}
+   * Create repository from model object (alternative to getRepository)
+   * @param {import('./types').ModelDefinition} model - Model definition
+   * @param {import('./types').ScopeContext} [scopeContext] - Scope context
+   * @returns {import('./types').Repository}
    */
-  async function destroy() {
-    await knexInstance.destroy();
+  function createRepositoryFromModel(model, scopeContext) {
+    const ctx = scopeContext || createScopeContext();
+    return createRepository(model, knexInstance, ctx);
   }
 
   /**
-   * Create a seeder instance
-   * @param {Object} faker - Faker instance (@faker-js/faker)
-   * @returns {Object} Seeder API
+   * Run operations in a transaction
+   * @param {Function} callback - Callback receiving transaction context
+   * @returns {Promise<*>} Result of callback
    */
-  function seeder(faker) {
-    return createSeeder(faker, knexInstance);
+  async function transaction(callback) {
+    return knexInstance.transaction(async (trx) => {
+      // Create transaction context with repository methods
+      const trxContext = {
+        trx,
+        getRepository(modelName, scopeContext) {
+          const model = getModelInstance(modelName);
+          const ctx = scopeContext || createScopeContext();
+          return createRepository(model, trx, ctx);
+        },
+        createRepository(model, scopeContext) {
+          const ctx = scopeContext || createScopeContext();
+          return createRepository(model, trx, ctx);
+        },
+      };
+      return callback(trxContext);
+    });
   }
 
-  const db = {
+  return {
     knex: knexInstance,
-    createRepository: createRepo,
-    transaction,
     migrate,
-    seeder,
-    forTenant,
-    raw,
-    destroy,
+    getModel: getModelInstance,
+    hasModel: hasModelInstance,
+    getAllModels: getAllModelInstances,
+    registerModel,
+    getRepository,
+    createRepository: createRepositoryFromModel,
+    query,
+    transaction,
+    createSeeder: createSeederInstance,
+    destroy: () => knexInstance.destroy(),
   };
-
-  return db;
 }
 
-// Export everything
+// Export zdb instance directly
+const z = require('zod');
+const zdb = z ? createSchemaHelpers(z) : null;
+
 module.exports = {
   // Main factory
   createDatabase,
-
-  // Schema helpers - zdb instance (direct export)
+  // Schema helpers
   zdb,
   createSchemaHelpers,
-  extractColumnsFromSchema,
-  getColumnMeta,
-
-  // Model
+  // Model utilities
   defineModel,
   getModel,
   getAllModels,
   hasModel,
   clearRegistry,
-
-  // Repository (for direct use if needed)
-  createRepository,
-
-  // Query builder
-  createQueryBuilder,
-  QueryBuilder,
-
-  // Transaction
-  runTransaction,
-  createTransactionContext,
-
-  // Migrations
-  createMigrationManager,
-  scaffoldMigration,
-  scaffoldAlterMigration,
-  scaffoldDropMigration,
-
-  // Scopes
-  createScopeContext,
-
-  // Seeder
-  createSeeder,
+  // Column utilities
+  extractColumnsFromSchema,
+  getColumnMeta,
 };
-

package/core/orm/model.js

@@ -80,7 +80,7 @@ function defineModel(options) {
     },
     columns,
     admin: {
-      enabled: admin.enabled || false,
+      enabled: admin.enabled === true, // Explicit boolean check
       label: admin.label || name,
       icon: admin.icon || null,
       customFields: admin.customFields || {},

package/core/orm/types.js

@@ -215,6 +215,7 @@
 
 /**
  * @typedef {Object} DatabaseConfig
+ * @property {string} [models] - Path to models directory (default: './models')
  * @property {string} client - Database client ('pg', 'mysql2', 'better-sqlite3')
  * @property {string|Object} connection - Connection string or config object
  * @property {MigrationConfig} [migrations] - Migration configuration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webspresso",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Minimal, production-ready SSR framework for Node.js with file-based routing, Nunjucks templating, built-in i18n, and CLI tooling",
   "main": "index.js",
   "bin": {
@@ -50,7 +50,7 @@
   },
   "peerDependencies": {
     "@faker-js/faker": "^9.0.0",
-    "better-sqlite3": "^9.0.0",
+    "better-sqlite3": "^11.10.0",
     "dotenv": "^16.0.0",
     "mysql2": "^3.0.0",
     "pg": "^8.0.0"
@@ -75,7 +75,7 @@
   "devDependencies": {
     "@faker-js/faker": "^9.3.0",
     "@vitest/coverage-v8": "^1.2.0",
-    "better-sqlite3": "^11.0.0",
+    "better-sqlite3": "^11.10.0",
     "chokidar": "^3.5.3",
     "dotenv": "^16.3.1",
     "release-it": "^17.11.0",

package/plugins/admin-panel/api.js

@@ -25,7 +25,7 @@ function createApiHandlers(options) {
   // Get AdminUser repository
   let AdminUserRepo = null;
   if (db && AdminUser) {
-    AdminUserRepo = db.createRepository(AdminUser);
+    AdminUserRepo = db.getRepository(AdminUser.name);
   }
 
   /**
@@ -131,7 +131,7 @@ function createApiHandlers(options) {
       const adminModels = [];
 
       for (const [name, model] of allModels) {
-        if (model.admin && model.admin.enabled) {
+        if (model.admin && model.admin.enabled === true) {
           adminModels.push({
             name: model.name,
             table: model.table,
@@ -162,7 +162,7 @@ function createApiHandlers(options) {
         return res.status(404).json({ error: 'Model not found' });
       }
 
-      if (!model.admin || !model.admin.enabled) {
+      if (!model.admin || model.admin.enabled !== true) {
         return res.status(403).json({ error: 'Model not enabled in admin panel' });
       }
 
@@ -204,11 +204,11 @@ function createApiHandlers(options) {
       const { model: modelName } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
-      const repo = db.createRepository(model);
+      const repo = db.getRepository(model.name);
       const page = parseInt(req.query.page) || 1;
       const perPage = parseInt(req.query.perPage) || 15;
       const offset = (page - 1) * perPage;
@@ -270,11 +270,11 @@ function createApiHandlers(options) {
       const { model: modelName, id } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
-      const repo = db.createRepository(model);
+      const repo = db.getRepository(model.name);
       const record = await repo.findById(id);
 
       if (!record) {
@@ -295,11 +295,11 @@ function createApiHandlers(options) {
       const { model: modelName } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
-      const repo = db.createRepository(model);
+      const repo = db.getRepository(model.name);
       const record = await repo.create(req.body);
 
       res.status(201).json({ data: record });
@@ -316,11 +316,11 @@ function createApiHandlers(options) {
       const { model: modelName, id } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
-      const repo = db.createRepository(model);
+      const repo = db.getRepository(model.name);
       const record = await repo.update(id, req.body);
 
       if (!record) {
@@ -341,11 +341,11 @@ function createApiHandlers(options) {
       const { model: modelName, id } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
-      const repo = db.createRepository(model);
+      const repo = db.getRepository(model.name);
       const deleted = await repo.delete(id);
 
       if (!deleted) {
@@ -366,7 +366,7 @@ function createApiHandlers(options) {
       const { model: modelName, relation: relationName } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
@@ -376,7 +376,7 @@ function createApiHandlers(options) {
       }
 
       const relatedModel = relation.model();
-      const relatedRepo = db.createRepository(relatedModel);
+      const relatedRepo = db.getRepository(relatedModel.name);
 
       // Get all related records (for dropdown/select)
       const records = await relatedRepo.findAll();
@@ -395,7 +395,7 @@ function createApiHandlers(options) {
       const { model: modelName, query: queryName } = req.params;
       const model = getModel(modelName);
 
-      if (!model || !model.admin || !model.admin.enabled) {
+      if (!model || !model.admin || model.admin.enabled !== true) {
         return res.status(404).json({ error: 'Model not found or not enabled' });
       }
 
@@ -404,7 +404,7 @@ function createApiHandlers(options) {
         return res.status(404).json({ error: 'Query not found' });
       }
 
-      const repo = db.createRepository(model);
+      const repo = db.getRepository(model.name);
       const result = await queryFn(repo);
 
       res.json({ data: result });

package/plugins/admin-panel/index.js

@@ -44,36 +44,40 @@ function adminPanelPlugin(options = {}) {
     /**
      * Register hook - called when plugin is registered
      */
-    async register(ctx) {
-      // Create and register AdminUser model (only if not already registered)
-      const { getModel } = require('../../core/orm/model');
-      let AdminUser = getModel('AdminUser');
-      
-      if (!AdminUser) {
-        AdminUser = createAdminUserModel();
-      }
-
-      // Store in plugin context for later use
-      this._adminUser = AdminUser;
-      this._db = db;
-      this._bcrypt = bcrypt;
-      this._session = session;
-      this._adminPath = adminPath;
+    register(ctx) {
+      // Ensure enabled is set
+      this.enabled = enabled;
     },
 
     /**
      * Routes ready hook - called after routes are mounted
      */
     onRoutesReady(ctx) {
-      if (!this.enabled) {
+      // Use closure variable 'enabled' directly (plugin.enabled property)
+      if (!enabled) {
         return;
       }
 
       const { app } = ctx;
-      const AdminUser = this._adminUser;
-      const db = this._db;
-      const bcrypt = this._bcrypt;
-      const session = this._session;
+      
+      // Create and register AdminUser model
+      // Check global registry first (defineModel adds to global registry)
+      const { hasModel: hasGlobalModel, getModel: getGlobalModel } = require('../../core/orm/model');
+      let AdminUser;
+      
+      if (hasGlobalModel('AdminUser')) {
+        // Model exists in global registry
+        AdminUser = getGlobalModel('AdminUser');
+        // Ensure it's also in db's local registry
+        if (!db.hasModel('AdminUser')) {
+          db.registerModel(AdminUser);
+        }
+      } else {
+        // Create AdminUser model (adds to global registry)
+        AdminUser = createAdminUserModel();
+        // Also add to db's local registry
+        db.registerModel(AdminUser);
+      }
 
       // Setup session middleware (only once, even if multiple plugins)
       // Check if session middleware is already registered

package/src/plugin-manager.js

@@ -127,7 +127,7 @@ class PluginManager {
   }
 
   /**
-   * Register plugins with the manager
+   * Register plugins with the manager (async version)
    * @param {Array} plugins - Array of plugin definitions or factory functions
    * @param {Object} context - Context object { app, nunjucksEnv, options }
    */
@@ -155,6 +155,34 @@ class PluginManager {
     }
   }
 
+  /**
+   * Register plugins with the manager (sync version)
+   * @param {Array} plugins - Array of plugin definitions or factory functions
+   * @param {Object} context - Context object { app, nunjucksEnv, options }
+   */
+  registerSync(plugins, context) {
+    if (!plugins || !Array.isArray(plugins)) return;
+
+    this.app = context.app;
+    this.nunjucksEnv = context.nunjucksEnv;
+
+    // Normalize plugins (handle factory functions)
+    const normalizedPlugins = plugins.map(p => {
+      if (typeof p === 'function') {
+        return p;
+      }
+      return p;
+    });
+
+    // Validate and sort by dependencies
+    const sorted = this._resolveDependencyOrder(normalizedPlugins);
+
+    // Register each plugin in order (sync)
+    for (const plugin of sorted) {
+      this._registerPluginSync(plugin, context);
+    }
+  }
+
   /**
    * Resolve dependency order using topological sort
    */
@@ -213,7 +241,7 @@ class PluginManager {
   }
 
   /**
-   * Register a single plugin
+   * Register a single plugin (async)
    */
   async _registerPlugin(plugin, context) {
     // Validate dependencies
@@ -244,6 +272,38 @@ class PluginManager {
     this._applyHelpersAndFilters();
   }
 
+  /**
+   * Register a single plugin (sync)
+   */
+  _registerPluginSync(plugin, context) {
+    // Validate dependencies
+    this._validateDependencies(plugin);
+
+    // Create plugin context
+    const ctx = this._createPluginContext(plugin, context);
+
+    // Store plugin
+    this.plugins.set(plugin.name, plugin);
+
+    // Store API if provided
+    if (plugin.api) {
+      // Bind API methods to plugin instance
+      const boundAPI = {};
+      for (const [key, value] of Object.entries(plugin.api)) {
+        boundAPI[key] = typeof value === 'function' ? value.bind(plugin) : value;
+      }
+      this.pluginAPIs.set(plugin.name, boundAPI);
+    }
+
+    // Call register hook (sync - if plugin has async register, it won't wait)
+    if (typeof plugin.register === 'function') {
+      plugin.register(ctx);
+    }
+
+    // Apply registered helpers to nunjucks
+    this._applyHelpersAndFilters();
+  }
+
   /**
    * Validate plugin dependencies
    */

package/src/server.js

@@ -219,9 +219,9 @@ function createApp(options = {}) {
     return d.toString();
   });
   
-  // Register plugins (synchronous part)
+  // Register plugins (sync)
   const pluginContext = { app, nunjucksEnv, options };
-  pluginManager.register(plugins, pluginContext);
+  pluginManager.registerSync(plugins, pluginContext);
   
   // Request logging middleware
   if (logging) {