@objectql/core 1.0.0 → 1.1.0

package/src/index.ts

@@ -5,19 +5,26 @@ export * from './types';
 export * from './driver';
 export * from './repository';
 export * from './query';
+export * from './registry';
+export * from './loader';
 
 import { ObjectConfig } from './metadata';
 import { ObjectQLContext, ObjectQLContextOptions, IObjectQL, ObjectQLConfig } from './types';
 import { ObjectRepository } from './repository';
 import { Driver } from './driver';
-import { loadObjectConfigs } from './loader';
+import { MetadataLoader } from './loader';
+import { MetadataRegistry } from './registry';
 
 export class ObjectQL implements IObjectQL {
-    private objects: Record<string, ObjectConfig> = {};
+    public metadata: MetadataRegistry;
+    private loader: MetadataLoader;
     private datasources: Record<string, Driver> = {};
 
     constructor(config: ObjectQLConfig) {
+        this.metadata = config.registry || new MetadataRegistry();
+        this.loader = new MetadataLoader(this.metadata);
         this.datasources = config.datasources;
+
         if (config.objects) {
             for (const [key, obj] of Object.entries(config.objects)) {
                 this.registerObject(obj);
@@ -25,26 +32,22 @@ export class ObjectQL implements IObjectQL {
         }
         if (config.packages) {
             for (const name of config.packages) {
-                try {
-                    this.loadFromPackage(name);
-                } catch (e) {
-                    this.loadFromDirectory(name);
-                }
+                this.addPackage(name);
             }
         }
     }
 
-    loadFromPackage(name: string) {
-        const entryPath = require.resolve(name, { paths: [process.cwd()] });
-        const packageDir = path.dirname(entryPath);
-        this.loadFromDirectory(packageDir);
+    addPackage(name: string) {
+        this.loader.loadPackage(name);
     }
 
-    loadFromDirectory(dir: string) {
-        const objects = loadObjectConfigs(dir);
-        for (const obj of Object.values(objects)) {
-            this.registerObject(obj);
-        }
+
+    removePackage(name: string) {
+        this.metadata.unregisterPackage(name);
+    }
+
+    loadFromDirectory(dir: string, packageName?: string) {
+        this.loader.load(dir, packageName);
     }
 
     createContext(options: ObjectQLContextOptions): ObjectQLContext {
@@ -67,14 +70,12 @@ export class ObjectQL implements IObjectQL {
                  try {
                      trx = await driver.beginTransaction();
                  } catch (e) {
-                     // If beginTransaction fails, fail.
                      throw e;
                  }
 
                  const trxCtx: ObjectQLContext = {
                      ...ctx,
                      transactionHandle: trx,
-                     // Nested transaction simply reuses the current one (flat transaction)
                      transaction: async (cb) => cb(trxCtx)
                  };
 
@@ -103,15 +104,24 @@ export class ObjectQL implements IObjectQL {
                 }
             }
         }
-        this.objects[object.name] = object;
+        this.metadata.register('object', {
+            type: 'object',
+            id: object.name,
+            content: object
+        });
     }
 
     getObject(name: string): ObjectConfig | undefined {
-        return this.objects[name];
+        return this.metadata.get<ObjectConfig>('object', name);
     }
 
     getConfigs(): Record<string, ObjectConfig> {
-        return this.objects;
+        const result: Record<string, ObjectConfig> = {};
+        const objects = this.metadata.list<ObjectConfig>('object');
+        for (const obj of objects) {
+            result[obj.name] = obj;
+        }
+        return result;
     }
 
     datasource(name: string): Driver {
@@ -124,11 +134,11 @@ export class ObjectQL implements IObjectQL {
 
     async init() {
         const ctx = this.createContext({ isSystem: true });
-        for (const objectName in this.objects) {
-            const obj = this.objects[objectName];
+        const objects = this.metadata.list<ObjectConfig>('object');
+        for (const obj of objects) {
             if (obj.data && obj.data.length > 0) {
-                console.log(`Initializing data for object ${objectName}...`);
-                const repo = ctx.object(objectName);
+                console.log(`Initializing data for object ${obj.name}...`);
+                const repo = ctx.object(obj.name);
                 for (const record of obj.data) {
                     try {
                         if (record._id) {
@@ -138,9 +148,9 @@ export class ObjectQL implements IObjectQL {
                              }
                         }
                         await repo.create(record);
-                        console.log(`Inserted init data for ${objectName}: ${record._id || 'unknown id'}`);
+                        console.log(`Inserted init data for ${obj.name}: ${record._id || 'unknown id'}`);
                     } catch (e) {
-                        console.error(`Failed to insert init data for ${objectName}:`, e);
+                        console.error(`Failed to insert init data for ${obj.name}:`, e);
                     }
                 }
             }

package/src/loader.ts

@@ -1,194 +1,22 @@
-import * as fs from 'fs';
-import * as path from 'path';
-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
-    });
-
-    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;
-                    }
-                }
-            }
-        } 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];
-                }
-            }
-
-            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 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;
-            }
-
-            // 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}`);
-            }
-
-        } catch (e) {
-            console.error(`Error loading data from ${file}:`, e);
-        }
+import { MetadataRegistry } from './registry';
+import { ObjectConfig } from './types';
+import { MetadataLoader as BaseLoader, registerObjectQLPlugins } from '@objectql/metadata';
+
+export class MetadataLoader extends BaseLoader {
+    constructor(registry: MetadataRegistry) {
+        super(registry);
+        registerObjectQLPlugins(this);
     }
+}
 
-    // 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];
-                }
-            }
-
-            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;
-                     }
-                 }
-            }
-        } catch (e) {
-            console.error(`Error loading action from ${file}:`, e);
-        }
+export function loadObjectConfigs(dir: string): Record<string, ObjectConfig> {
+    const registry = new MetadataRegistry();
+    const loader = new MetadataLoader(registry);
+    loader.load(dir);
+    const result: Record<string, ObjectConfig> = {};
+    for (const obj of registry.list<ObjectConfig>('object')) {
+        result[obj.name] = obj;
     }
-    
-    return configs;
+    return result;
 }
 

package/src/registry.ts

@@ -0,0 +1,6 @@
+import { MetadataRegistry as BaseRegistry, Metadata } from '@objectql/metadata';
+
+export { Metadata };
+export class MetadataRegistry extends BaseRegistry {
+    // Re-export or extend if needed
+}

package/src/types.ts

@@ -2,10 +2,13 @@ import { ObjectRepository } from "./repository";
 import { ObjectConfig } from "./metadata";
 import { Driver } from "./driver";
 import { UnifiedQuery, FilterCriterion } from "./query";
+import { MetadataRegistry } from "./registry";
 
 export { ObjectConfig } from "./metadata";
+export { MetadataRegistry } from "./registry";
 
 export interface ObjectQLConfig {
+    registry?: MetadataRegistry;
     datasources: Record<string, Driver>;
     objects?: Record<string, ObjectConfig>;
     packages?: string[];
@@ -16,6 +19,9 @@ export interface IObjectQL {
     getConfigs(): Record<string, ObjectConfig>;
     datasource(name: string): Driver;
     init(): Promise<void>;
+    addPackage(name: string): void;
+    removePackage(name: string): void;
+    metadata: MetadataRegistry; 
 }
 
 export interface HookContext<T = any> {

package/test/dynamic.test.ts

@@ -0,0 +1,34 @@
+import { ObjectQL } from '../src/index';
+import * as path from 'path';
+
+describe('Dynamic Package Loading', () => {
+    let objectql: ObjectQL;
+
+    beforeEach(() => {
+        objectql = new ObjectQL({
+            datasources: {}
+        });
+    });
+
+    test('should load directory manually', () => {
+        const fixtureDir = path.join(__dirname, 'fixtures');
+        objectql.loadFromDirectory(fixtureDir, 'test-pkg');
+        
+        expect(objectql.getObject('project')).toBeDefined();
+        // Since 'test-pkg' is passed, it should be tracked
+        // but packageObjects is private, so we test behavior by removal
+    });
+
+    test('should remove package objects', () => {
+        const fixtureDir = path.join(__dirname, 'fixtures');
+        objectql.loadFromDirectory(fixtureDir, 'test-pkg');
+        
+        expect(objectql.getObject('project')).toBeDefined();
+
+        objectql.removePackage('test-pkg');
+        expect(objectql.getObject('project')).toBeUndefined();
+    });
+
+    // Mocking require for loadFromPackage is harder in jest without creating a real node module.
+    // relying on loadFromDirectory with packageName argument is sufficient to test the tracking logic.
+});