@objectql/core 0.1.0 → 1.1.0

package/src/loader.ts

@@ -1,120 +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);
-        }
+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);
     }
+}
 
-    // 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);
-        }
+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/metadata.ts

@@ -1,4 +1,3 @@
-
 /**
  * Represents the supported field data types in the ObjectQL schema.
  * These types determine how data is stored, validated, and rendered.
@@ -138,4 +137,7 @@ export interface ObjectConfig {
 
     /** Lifecycle hooks. */
     listeners?: ObjectListeners;
+
+    /** Initial data to populate when system starts. */
+    data?: any[];
 }

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,18 +2,26 @@ 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[];
 }
 
 export interface IObjectQL {
     getObject(name: string): ObjectConfig | undefined;
     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.
+});

package/test/fixtures/project.action.ts

@@ -0,0 +1,6 @@
+// Fixture for testing action loader
+export const listenTo = 'project';
+
+export async function closeProject(ctx: any, params: any) {
+    return { success: true };
+}

package/test/loader.test.ts

@@ -11,4 +11,12 @@ describe('Loader', () => {
         expect(configs['project'].fields).toBeDefined();
         expect(configs['project'].fields.name).toBeDefined();
     });
+
+    it('should load actions from .action.ts files', () => {
+        const fixturesDir = path.join(__dirname, 'fixtures');
+        const configs = loadObjectConfigs(fixturesDir);
+        expect(configs['project'].actions).toBeDefined();
+        expect(configs['project'].actions!.closeProject).toBeDefined();
+        expect(typeof configs['project'].actions!.closeProject.handler).toBe('function');
+    });
 });