Refactor code structure for improved readability and maintainability

hotlong · hotlong · commit 3e1ee21f8412 · 2026-01-15T22:08:16.000+08:00
diff --git a/objectql.config.ts b/objectql.config.ts
@@ -5,7 +5,7 @@ export default {
             filename: 'objectos.db'
         }
     },
-    presets: [
+    modules: [
         '@objectql/starter-basic',
         '@objectql/starter-enterprise'
     ]
diff --git a/packages/foundation/platform-node/src/index.ts b/packages/foundation/platform-node/src/index.ts
@@ -1,3 +1,4 @@
 export * from './loader';
 export * from './plugin';
 export * from './driver';
+export * from './module';
diff --git a/packages/foundation/platform-node/src/module.ts b/packages/foundation/platform-node/src/module.ts
@@ -0,0 +1,70 @@
+import { ObjectLoader } from './loader';
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * Resolves a list of module names (npm packages or local paths) to their paths
+ * and loads them using ObjectLoader.
+ */
+export async function loadModules(loader: ObjectLoader, modules: string[]) {
+    if (!modules || modules.length === 0) return;
+    
+    console.log(`Loading ${modules.length} modules...`);
+    
+    for (const moduleName of modules) {
+        try {
+            // Check if it is a local path
+            if (moduleName.startsWith('./') || moduleName.startsWith('/') || moduleName.startsWith('../')) {
+                 const localPath = path.resolve(process.cwd(), moduleName);
+                 if (fs.existsSync(localPath)) {
+                     console.log(`  - ${moduleName} -> ${localPath}`);
+                     loader.load(localPath);
+                     continue;
+                 }
+            }
+
+            // 1. Resolve package path
+            // We use require.resolve to find the entry point, then go up to find the package root
+            const entryPath = require.resolve(moduleName, { paths: [process.cwd()] });
+            
+            // Let's try to find the package root directory
+            let currentDir = path.dirname(entryPath);
+            let packageRoot = '';
+            
+            // Go up until we find package.json
+            while (currentDir !== path.parse(currentDir).root) {
+                if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+                    // Check if name matches
+                    try {
+                        const pkg = require(path.join(currentDir, 'package.json'));
+                        if (pkg.name === moduleName) {
+                            packageRoot = currentDir;
+                            break;
+                        }
+                    } catch (e) {}
+                }
+                currentDir = path.dirname(currentDir);
+            }
+
+            if (!packageRoot) {
+                console.warn(`Could not find package root for module '${moduleName}'. Using entry directory.`);
+                packageRoot = path.dirname(entryPath);
+            }
+
+            // Now, where is the schema?
+            // Convention: check 'src', then root.
+            const srcDir = path.join(packageRoot, 'src');
+            const targetDir = fs.existsSync(srcDir) ? srcDir : packageRoot;
+            
+            console.log(`  - ${moduleName} -> ${targetDir}`);
+            
+            // Load it!
+            loader.load(targetDir);
+
+        } catch (e: any) {
+            console.warn(`Failed to load module '${moduleName}': ${e.message}`);
+        }
+    }
+}
+
+
diff --git a/packages/foundation/types/src/config.ts b/packages/foundation/types/src/config.ts
@@ -21,9 +21,14 @@ export interface ObjectQLConfig {
      */
     packages?: string[];
     /**
-     * List of npm packages or presets to load.
+     * @deprecated Use 'modules' instead.
      */
     presets?: string[];
+    /**
+     * List of modules to load.
+     * Can be npm packages or local directories.
+     */
+    modules?: string[];
     /**
      * List of plugins to load. 
      * Can be an instance of ObjectQLPlugin or a package name string.
diff --git a/packages/tools/cli/src/commands/dev.ts b/packages/tools/cli/src/commands/dev.ts
@@ -8,13 +8,20 @@ import chalk from 'chalk';
 export async function dev(options: { 
     port: number; 
     dir: string;
+    config?: string;
+    modules?: string;
     watch?: boolean;
 }) {
     console.log(chalk.cyan('🚀 Starting ObjectQL Development Server...\n'));
     
     // For now, delegate to serve command
     // In future, can add file watching and auto-reload
-    await serve({ port: options.port, dir: options.dir });
+    await serve({ 
+        port: options.port, 
+        dir: options.dir,
+        config: options.config,
+        modules: options.modules
+    });
     
     if (options.watch !== false) {
         console.log(chalk.yellow('\n👀 Watching for file changes... (Not yet implemented)'));
diff --git a/packages/tools/cli/src/commands/serve.ts b/packages/tools/cli/src/commands/serve.ts
@@ -1,9 +1,10 @@
 import { ObjectQL } from '@objectql/core';
 import { SqlDriver } from '@objectql/driver-sql';
-import { ObjectLoader } from '@objectql/platform-node';
+import { ObjectLoader, loadModules } from '@objectql/platform-node';
 import { createNodeHandler } from '@objectql/server';
 import { createServer } from 'http';
 import * as path from 'path';
+import * as fs from 'fs';
 import chalk from 'chalk';
 
 const CONSOLE_HTML = `
@@ -33,29 +34,89 @@ const CONSOLE_HTML = `
 </html>
 `;
 
-export async function serve(options: { port: number; dir: string }) {
+export async function serve(options: { 
+    port: number; 
+    dir: string;
+    config?: string;
+    modules?: string;
+}) {
     console.log(chalk.blue('Starting ObjectQL Dev Server...'));
     
     const rootDir = path.resolve(process.cwd(), options.dir);
     console.log(chalk.gray(`Loading schema from: ${rootDir}`));
 
-    // 1. Init ObjectQL with in-memory SQLite for Dev
+    // Try to load configuration
+    let config: any = null;
+    const configPath = options.config || path.join(process.cwd(), 'objectql.config.ts');
+    
+    if (fs.existsSync(configPath)) {
+        try {
+            console.log(chalk.gray(`Loading config from: ${configPath}`));
+            if (configPath.endsWith('.ts')) {
+                require('ts-node/register');
+            }
+            const loaded = require(configPath);
+            config = loaded.default || loaded;
+        } catch (e: any) {
+            console.warn(chalk.yellow(`⚠️ Failed to load config: ${e.message}`));
+        }
+    } else if (options.config) {
+        console.error(chalk.red(`❌ Config file not found: ${options.config}`));
+        process.exit(1);
+    }
+
+    // Process modules override
+    if (options.modules) {
+        const moduleList = options.modules.split(',').map(p => p.trim());
+        if (!config) config = {};
+        config.modules = moduleList;
+        console.log(chalk.yellow(`⚠️ Overriding modules: ${moduleList.join(', ')}`));
+    }
+
+    const loadedConfig = config?.datasource?.default || config?.datasources?.default;
+    let datasourceValue = loadedConfig;
+    
+    // Normalize config if it uses simplified format (type: 'sqlite')
+    if (loadedConfig && !loadedConfig.client && loadedConfig.type === 'sqlite') {
+        datasourceValue = {
+            client: 'sqlite3',
+            connection: {
+                filename: loadedConfig.filename || ':memory:'
+            },
+            useNullAsDefault: true
+        };
+    }
+
+    const datasource = datasourceValue || {
+        client: 'sqlite3',
+        connection: {
+            filename: ':memory:'
+        },
+        useNullAsDefault: true
+    };
+
+    // 1. Init ObjectQL
     const app = new ObjectQL({
         datasources: {
-            default: new SqlDriver({
-                client: 'sqlite3',
-                connection: {
-                    filename: ':memory:' // Or local file './dev.db'
-                },
-                useNullAsDefault: true
-            })
-        }
+            default: new SqlDriver(datasource)
+        },
+        ...config
     });
 
     // 2. Load Schema
     try {
         const loader = new ObjectLoader(app.metadata);
+        
+        // Load modules first (if any)
+        // Backwards compatibility for presets
+        const modulesToLoad = config?.modules || config?.presets;
+        if (modulesToLoad) {
+            await loadModules(loader, modulesToLoad);
+        }
+
+        // Load project source
         loader.load(rootDir);
+        
         await app.init();
         console.log(chalk.green('✅ Schema loaded successfully.'));
     } catch (e: any) {
diff --git a/packages/tools/cli/src/commands/start.ts b/packages/tools/cli/src/commands/start.ts
@@ -1,6 +1,6 @@
 import { ObjectQL } from '@objectql/core';
 import { SqlDriver } from '@objectql/driver-sql';
-import { ObjectLoader } from '@objectql/platform-node';
+import { ObjectLoader, loadModules } from '@objectql/platform-node';
 import { createNodeHandler } from '@objectql/server';
 import { createServer } from 'http';
 import * as path from 'path';
@@ -11,6 +11,7 @@ interface StartOptions {
     port: number;
     dir: string;
     config?: string;
+    modules?: string;
 }
 
 // Flexible config type that handles both ObjectQLConfig and custom config formats
@@ -49,6 +50,14 @@ export async function start(options: StartOptions) {
         }
     }
 
+    // Process modules override
+    if (options.modules) {
+        const moduleList = options.modules.split(',').map(p => p.trim());
+        if (!config) config = {};
+        config.modules = moduleList;
+        console.log(chalk.yellow(`⚠️ Overriding modules: ${moduleList.join(', ')}`));
+    }
+
     // Initialize datasource from config or use default SQLite
     // Note: Config files may use 'datasource' (singular) while ObjectQLConfig uses 'datasources' (plural)
     const datasourceConfig = config?.datasources?.default || config?.datasource?.default || {
@@ -67,7 +76,17 @@ export async function start(options: StartOptions) {
     // Load Schema
     try {
         const loader = new ObjectLoader(app.metadata);
+        
+        // Load modules first (if any)
+        // Backwards compatibility for presets
+        const modulesToLoad = config?.modules || config?.presets;
+        if (modulesToLoad) {
+            await loadModules(loader, modulesToLoad);
+        }
+
+        // Load project source
         loader.load(rootDir);
+        
         await app.init();
         console.log(chalk.green('✅ Schema loaded successfully.'));
     } catch (e: any) {
diff --git a/packages/tools/cli/src/index.ts b/packages/tools/cli/src/index.ts
@@ -193,11 +193,15 @@ program
     .description('Start development server with hot reload')
     .option('-p, --port <number>', 'Port to listen on', '3000')
     .option('-d, --dir <path>', 'Directory containing schema', '.')
+    .option('-c, --config <path>', 'Path to objectql.config.ts/js')
+    .option('--modules <items>', 'Comma-separated list of modules to load (overrides config)')
     .option('--no-watch', 'Disable file watching')
     .action(async (options) => {
         await dev({ 
             port: parseInt(options.port), 
             dir: options.dir,
+            config: options.config,
+            modules: options.modules,
             watch: options.watch
         });
     });
@@ -209,11 +213,13 @@ program
     .option('-p, --port <number>', 'Port to listen on', '3000')
     .option('-d, --dir <path>', 'Directory containing schema', '.')
     .option('-c, --config <path>', 'Path to objectql.config.ts/js')
+    .option('--modules <items>', 'Comma-separated list of modules to load (overrides config)')
     .action(async (options) => {
         await start({ 
             port: parseInt(options.port), 
             dir: options.dir,
-            config: options.config
+            config: options.config,
+            modules: options.modules
         });
     });
 
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ export default {`
`5`	`5`	`filename: 'objectos.db'`
`6`	`6`	`}`
`7`	`7`	`},`
`8`		`- presets: [`
	`8`	`+ modules: [`
`9`	`9`	`'@objectql/starter-basic',`
`10`	`10`	`'@objectql/starter-enterprise'`
`11`	`11`	`]`