@objectql/core 1.0.0 → 1.2.0

package/src/loader.ts

@@ -1,194 +1,206 @@
 import * as fs from 'fs';
+import * as glob from 'fast-glob';
 import * as path from 'path';
+import { ObjectRegistry, ObjectConfig } from '@objectql/types';
 import * as yaml from 'js-yaml';
-import * as glob from 'fast-glob';
-import { ObjectQLConfig, ObjectConfig } from './types';
 
-export function loadObjectConfigs(dir: string): Record<string, ObjectConfig> {
-    const configs: Record<string, ObjectConfig> = {};
-    
-    // 1. Load YAML Configs
-    const files = glob.sync(['**/*.object.yml', '**/*.object.yaml'], {
-        cwd: dir,
-        absolute: true
-    });
+export interface LoaderHandlerContext {
+    file: string;
+    content: string;
+    registry: ObjectRegistry;
+    packageName?: string;
+}
 
-    for (const file of files) {
-        try {
-            const content = fs.readFileSync(file, 'utf8');
-            const doc = yaml.load(content) as any;
-            
-            if (doc.name && doc.fields) {
-                configs[doc.name] = doc as ObjectConfig;
-            } else {
-                for (const [key, value] of Object.entries(doc)) {
-                    if (typeof value === 'object' && (value as any).fields) {
-                         configs[key] = value as ObjectConfig;
-                         if (!configs[key].name) configs[key].name = key;
+export type LoaderHandler = (ctx: LoaderHandlerContext) => void;
+
+export interface LoaderPlugin {
+    name: string;
+    glob: string[];
+    handler: LoaderHandler;
+    options?: any;
+}
+
+export class ObjectLoader {
+    private plugins: LoaderPlugin[] = [];
+
+    constructor(protected registry: ObjectRegistry) {
+        this.registerBuiltinPlugins();
+    }
+
+    private registerBuiltinPlugins() {
+        // Objects
+        this.use({
+            name: 'object',
+            glob: ['**/*.object.yml', '**/*.object.yaml'],
+            handler: (ctx) => {
+                try {
+                    const doc = yaml.load(ctx.content) as any;
+                    if (!doc) return;
+
+                    if (doc.name && doc.fields) {
+                        registerObject(ctx.registry, doc, ctx.file, ctx.packageName || ctx.registry.getEntry('package-map', ctx.file)?.package);
+                    } else {
+                        for (const [key, value] of Object.entries(doc)) {
+                            if (typeof value === 'object' && (value as any).fields) {
+                                const obj = value as any;
+                                if (!obj.name) obj.name = key;
+                                registerObject(ctx.registry, obj, ctx.file, ctx.packageName);
+                            }
+                        }
                     }
+                } catch (e) {
+                    console.error(`Error loading object from ${ctx.file}:`, e);
                 }
             }
-        } catch (e) {
-            console.error(`Error loading object config from ${file}:`, e);
-        }
-    }
-
-    // 2. Load Hooks (.hook.js, .hook.ts)
-    // We only load .js if running in node, or .ts if ts-node/register is present.
-    // simpler: look for both, require will handle extension resolution if we are careful.
-    // Actually, in `dist` we only find .js. In `src` (test) we find .ts.
-    const hookFiles = glob.sync(['**/*.hook.{js,ts}'], {
-        cwd: dir,
-        absolute: true
-    });
-
-    for (const file of hookFiles) {
-        try {
-            // Check if we should ignore .ts if .js exists? 
-            // Or assume env handles it.
-            // If we are in `dist`, `src` shouldn't be there usually.
-            
-            const hookModule = require(file);
-            // Default export or named exports?
-            // Convention: export const listenTo = 'objectName';
-            // or filename based: 'project.hook.js' -> 'project' (flaky)
-            
-            let objectName = hookModule.listenTo;
-            
-            if (!objectName) {
-                // Try to guess from filename? 
-                // project.hook.ts -> project
-                const basename = path.basename(file);
-                const match = basename.match(/^(.+)\.hook\.(ts|js)$/);
-                if (match) {
-                    objectName = match[1];
+        });
+
+        // Hooks
+        this.use({
+            name: 'hook',
+            glob: ['**/*.hook.ts', '**/*.hook.js'],
+            handler: (ctx) => {
+                const basename = path.basename(ctx.file);
+                // Extract object name from filename: user.hook.ts -> user
+                const objectName = basename.replace(/\.hook\.(ts|js)$/, '');
+                
+                try {
+                    const mod = require(ctx.file);
+                    // Support default export or named exports
+                    const hooks = mod.default || mod;
+                    
+                    ctx.registry.register('hook', {
+                        type: 'hook',
+                        id: objectName, // Hook ID is the object name
+                        path: ctx.file,
+                        package: ctx.packageName,
+                        content: hooks
+                    });
+                } catch (e) {
+                    console.error(`Error loading hook from ${ctx.file}:`, e);
                 }
             }
+        });
+        
+        // Actions
+        this.use({
+            name: 'action',
+            glob: ['**/*.action.ts', '**/*.action.js'],
+            handler: (ctx) => {
+                const basename = path.basename(ctx.file);
+                // Extract object name: invoice.action.ts -> invoice
+                const objectName = basename.replace(/\.action\.(ts|js)$/, '');
+                
+                try {
+                    const mod = require(ctx.file);
+                    // Action file exports multiple actions
+                    // export const approve = { ... };
+                    // export const reject = { ... };
+                    
+                    const actions: Record<string, any> = {};
+                    
+                    for (const [key, value] of Object.entries(mod)) {
+                        if (key === 'default') continue;
+                        if (typeof value === 'object' && (value as any).handler) {
+                            actions[key] = value;
+                        }
+                    }
+                    
+                    if (Object.keys(actions).length > 0) {
+                         ctx.registry.register('action', {
+                            type: 'action',
+                            id: objectName, // Action collection ID is the object name
+                            path: ctx.file,
+                            package: ctx.packageName,
+                            content: actions
+                        });
+                    }
 
-            if (objectName && configs[objectName]) {
-                 if (!configs[objectName].listeners) {
-                     configs[objectName].listeners = {};
-                 }
-                 const listeners = configs[objectName].listeners!;
-                 
-                 // Merge exported functions into listeners
-                 // Common hooks: beforeFind, afterFind, beforeCreate, etc.
-                 const hookNames = [
-                     'beforeFind', 'afterFind',
-                     'beforeCreate', 'afterCreate',
-                     'beforeUpdate', 'afterUpdate',
-                     'beforeDelete', 'afterDelete'
-                 ];
-
-                 for (const name of hookNames) {
-                     if (typeof hookModule[name] === 'function') {
-                         listeners[name as keyof typeof listeners] = hookModule[name];
-                     }
-                 }
-                 // Support default export having listeners object?
-                 if (hookModule.default && typeof hookModule.default === 'object') {
-                      Object.assign(listeners, hookModule.default);
-                 }
-
-                 // Load Actions
-                 // Convention: export const actions = { myAction: (ctx, params) => ... }
-                 // OR export function myAction(ctx, params) ... (Ambiguous with hooks? No, hooks have explicit names)
-                 // Safer: look for `actions` export.
-                 
-                 if (hookModule.actions && typeof hookModule.actions === 'object') {
-                     if (!configs[objectName].actions) {
-                         configs[objectName].actions = {};
-                     }
-                     
-                     for (const [actionName, handler] of Object.entries(hookModule.actions)) {
-                         // We might have metadata from YAML already
-                         if (!configs[objectName].actions![actionName]) {
-                             configs[objectName].actions![actionName] = { };
-                         }
-                         // Attach handler
-                         configs[objectName].actions![actionName].handler = handler as any;
-                     }
-                 }
+                } catch (e) {
+                    console.error(`Error loading action from ${ctx.file}:`, e);
+                }
             }
-        } catch (e) {
-            console.error(`Error loading hook from ${file}:`, e);
-        }
+        });
     }
 
-    // 3. Load Data (.data.yml, .data.yaml)
-    const dataFiles = glob.sync(['**/*.data.yml', '**/*.data.yaml'], {
-        cwd: dir,
-        absolute: true
-    });
-
-    for (const file of dataFiles) {
-        try {
-            const content = fs.readFileSync(file, 'utf8');
-            const data = yaml.load(content);
-
-            if (!Array.isArray(data)) {
-                console.warn(`Data file ${file} does not contain an array. Skipping.`);
-                continue;
-            }
+    use(plugin: LoaderPlugin) {
+        this.plugins.push(plugin);
+    }
 
-            // Guess object name from filename
-            // project.data.yml -> project
-            const basename = path.basename(file);
-            const objectName = basename.replace(/\.data\.ya?ml$/, '');
-
-            if (configs[objectName]) {
-                configs[objectName].data = data;
-            } else {
-                // Maybe the object config hasn't been found yet? 
-                // loadObjectConfigs runs glob for objects first, so configs should be populated.
-                console.warn(`Found data for unknown object '${objectName}' in ${file}`);
-            }
+    load(dir: string, packageName?: string) {
+        for (const plugin of this.plugins) {
+            this.runPlugin(plugin, dir, packageName);
+        }
+    }
 
+    loadPackage(packageName: string) {
+        try {
+            const entryPath = require.resolve(packageName, { paths: [process.cwd()] });
+            // clean cache
+            delete require.cache[entryPath];
+            const packageDir = path.dirname(entryPath);
+            this.load(packageDir, packageName);
         } catch (e) {
-            console.error(`Error loading data from ${file}:`, e);
+            // fallback to directory
+            this.load(packageName, packageName);
         }
     }
 
-    // 4. Load Actions (.action.js, .action.ts)
-    const actionFiles = glob.sync(['**/*.action.{js,ts}'], {
-        cwd: dir,
-        absolute: true
-    });
-
-    for (const file of actionFiles) {
-        try {
-            const actionModule = require(file);
-            let objectName = actionModule.listenTo;
-            
-            if (!objectName) {
-                const basename = path.basename(file);
-                const match = basename.match(/^(.+)\.action\.(ts|js)$/);
-                if (match) {
-                    objectName = match[1];
+    private runPlugin(plugin: LoaderPlugin, dir: string, packageName?: string) {
+        const files = glob.sync(plugin.glob, {
+            cwd: dir,
+            absolute: true
+        });
+
+        for (const file of files) {
+            try {
+                const ctx: LoaderHandlerContext = {
+                    file,
+                    content: '',
+                    registry: this.registry,
+                    packageName
+                };
+                
+                // Pre-read for convenience
+                if (!file.match(/\.(js|ts|node)$/)) {
+                    ctx.content = fs.readFileSync(file, 'utf8');
                 }
+
+                plugin.handler(ctx);
+
+            } catch (e) {
+                console.error(`Error in loader plugin '${plugin.name}' processing ${file}:`, e);
             }
+        }
+    }
+}
 
-            if (objectName && configs[objectName]) {
-                 if (!configs[objectName].actions) {
-                     configs[objectName].actions = {};
-                 }
-                 
-                 // Treat all exported functions as actions
-                 for (const [key, value] of Object.entries(actionModule)) {
-                     if (key === 'listenTo') continue;
-                     if (typeof value === 'function') {
-                         if (!configs[objectName].actions![key]) {
-                             configs[objectName].actions![key] = {};
-                         }
-                         configs[objectName].actions![key].handler = value as any;
-                     }
-                 }
+function registerObject(registry: ObjectRegistry, obj: any, file: string, packageName?: string) {
+    // Normalize fields
+    if (obj.fields) {
+        for (const [key, field] of Object.entries(obj.fields)) {
+            if (typeof field === 'object' && field !== null) {
+                if (!(field as any).name) {
+                    (field as any).name = key;
+                }
             }
-        } catch (e) {
-            console.error(`Error loading action from ${file}:`, e);
         }
     }
-    
-    return configs;
+    registry.register('object', {
+        type: 'object',
+        id: obj.name,
+        path: file,
+        package: packageName,
+        content: obj
+    });
 }
 
+export function loadObjectConfigs(dir: string): Record<string, ObjectConfig> {
+    const registry = new ObjectRegistry();
+    const loader = new ObjectLoader(registry);
+    loader.load(dir);
+    const result: Record<string, ObjectConfig> = {};
+    for (const obj of registry.list<ObjectConfig>('object')) {
+        result[obj.name] = obj;
+    }
+    return result;
+}