@objectql/core 1.4.0 → 1.6.0

package/src/app.ts

@@ -14,21 +14,16 @@ import {
     ActionContext,
     LoaderPlugin
 } from '@objectql/types';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import { ObjectLoader } from './loader';
 import { ObjectRepository } from './repository';
-import { loadPlugin } from './plugin';
-import { createDriverFromConnection } from './driver';
-import { loadRemoteFromUrl } from './remote';
+// import { createDriverFromConnection } from './driver'; // REMOVE THIS
+
+// import { loadRemoteFromUrl } from './remote';
 import { executeActionHelper, registerActionHelper, ActionEntry } from './action';
 import { registerHookHelper, triggerHookHelper, HookEntry } from './hook';
 import { registerObjectHelper, getConfigsHelper } from './object';
 
 export class ObjectQL implements IObjectQL {
     public metadata: MetadataRegistry;
-    private loader: ObjectLoader;
     private datasources: Record<string, Driver> = {};
     private remotes: string[] = [];
     private hooks: Record<string, HookEntry[]> = {};
@@ -41,30 +36,24 @@ export class ObjectQL implements IObjectQL {
     constructor(config: ObjectQLConfig) {
         this.config = config;
         this.metadata = config.registry || new MetadataRegistry();
-        this.loader = new ObjectLoader(this.metadata);
         this.datasources = config.datasources || {};
-        this.remotes = config.remotes || [];
+        // this.remotes = config.remotes || [];
         
         if (config.connection) {
-            this.datasources['default'] = createDriverFromConnection(config.connection);
+             throw new Error("Connection strings are not supported in core directly. Use @objectql/platform-node's createDriverFromConnection or pass a driver instance to 'datasources'.");
         }
 
         // Initialize Plugin List (but don't setup yet)
         if (config.plugins) {
             for (const plugin of config.plugins) {
                 if (typeof plugin === 'string') {
-                    this.use(loadPlugin(plugin));
+                    throw new Error("String plugins are not supported in core. Use @objectql/platform-node or pass plugin instance.");
                 } else {
                     this.use(plugin);
                 }
             }
         }
     }
-
-    addPackage(name: string) {
-        this.loader.loadPackage(name);
-    }
-
     use(plugin: ObjectQLPlugin) {
         this.pluginsList.push(plugin);
     }
@@ -101,58 +90,6 @@ export class ObjectQL implements IObjectQL {
         return await executeActionHelper(this.metadata, this.actions, objectName, actionName, ctx);
     }
 
-    loadFromDirectory(dir: string, packageName?: string) {
-        this.loader.load(dir, packageName);
-    }
-
-    addLoader(plugin: LoaderPlugin) {
-        this.loader.use(plugin);
-    }
-
-    async updateMetadata(type: string, id: string, content: any): Promise<void> {
-        // Use registry to find the entry so we can get the file path
-        const entry = this.metadata.getEntry(type, id);
-        if (!entry) {
-            throw new Error(`Metadata ${type}:${id} not found`);
-        }
-
-        if (!entry.path) {
-            throw new Error('Cannot update: Metadata source file not found (in-memory only?)');
-        }
-
-        // Safety Check: Prevent writing to node_modules
-        if (entry.path.includes('node_modules')) {
-            throw new Error(`Cannot update metadata ${type}:${id}: File is inside node_modules (read-only package).`);
-        }
-
-        // Check file extension
-        const ext = path.extname(entry.path).toLowerCase();
-        let newContent = '';
-
-        if (ext === '.yml' || ext === '.yaml') {
-            newContent = yaml.dump(content);
-        } else if (ext === '.json') {
-            newContent = JSON.stringify(content, null, 2);
-        } else {
-            throw new Error(`Cannot update: Unsupported file format ${ext} (only .yml, .yaml, .json supported)`);
-        }
-
-        // Write file
-        try {
-            await fs.promises.chmod(entry.path, 0o666).catch(() => {}); // Try to ensure writable
-            await fs.promises.writeFile(entry.path, newContent, 'utf8');
-        } catch (e: any) {
-            throw new Error(`Failed to write file ${entry.path}: ${e.message}`);
-        }
-
-        // Update registry in-memory
-        entry.content = content;
-        
-        // If it's an object update, we might need some re-processing? 
-        // For now, assume a restart or reload is needed for deep schema changes, 
-        // but simple property updates are reflected immediately in registry.
-    }
-
     createContext(options: ObjectQLContextOptions): ObjectQLContext {
         const ctx: ObjectQLContext = {
             userId: options.userId,
@@ -249,26 +186,9 @@ export class ObjectQL implements IObjectQL {
             await plugin.setup(app);
         }
 
-        // 1. Load Presets/Packages (Base Layer) - AFTER plugins, so they can use new loaders
-        if (this.config.packages) {
-            for (const name of this.config.packages) {
-                this.addPackage(name);
-            }
-        }
-        if (this.config.presets) {
-            for (const name of this.config.presets) {
-                this.addPackage(name);
-            }
-        }
-
-        // 2. Load Local Sources (Application Layer)
-        if (this.config.source) {
-            const sources = Array.isArray(this.config.source) ? this.config.source : [this.config.source];
-            for (const src of sources) {
-                this.loader.load(src);
-            }
-        }
-
+        // Packages, Presets, Source, Objects loading logic removed from Core.
+        // Use @objectql/platform-node's ObjectLoader or platform-specific loaders.
+        
         // 3. Load In-Memory Objects (Dynamic Layer)
         if (this.config.objects) {
             for (const [key, obj] of Object.entries(this.config.objects)) {
@@ -276,23 +196,9 @@ export class ObjectQL implements IObjectQL {
             }
         }
 
-        // 4. Load Remotes
-        if (this.remotes.length > 0) {
-            console.log(`Loading ${this.remotes.length} remotes...`);
-            const results = await Promise.all(this.remotes.map(url => loadRemoteFromUrl(url)));
-            for (const res of results) {
-                if (res) {
-                    this.datasources[res.driverName] = res.driver;
-                    for (const obj of res.objects) {
-                        this.registerObject(obj);
-                    }
-                }
-            }
-        }
-
         const objects = this.metadata.list<ObjectConfig>('object');
         
-        // 5. Init Drivers (e.g. Sync Schema)
+        // 5. Init Datasources
         // Let's pass all objects to all configured drivers.
         for (const [name, driver] of Object.entries(this.datasources)) {
             if (driver.init) {
@@ -300,5 +206,59 @@ export class ObjectQL implements IObjectQL {
                 await driver.init(objects);
             }
         }
+
+        // 6. Process Initial Data
+        await this.processInitialData();
+    }
+
+    private async processInitialData() {
+        const dataEntries = this.metadata.list<any>('data');
+        if (dataEntries.length === 0) return;
+
+        console.log(`Processing ${dataEntries.length} initial data files...`);
+        
+        // We need a system context to write data
+        const ctx = this.createContext({ isSystem: true });
+
+        for (const entry of dataEntries) {
+            // Expected format:
+            // 1. { object: 'User', records: [...] }
+            // 2. [ record1, record2 ] (with name property added by loader inferred from filename)
+            
+            let objectName = entry.object;
+            let records = entry.records;
+
+            if (Array.isArray(entry)) {
+                records = entry;
+                if (!objectName && (entry as any).name) {
+                    objectName = (entry as any).name;
+                }
+            }
+
+            if (!objectName || !records || !Array.isArray(records)) {
+                console.warn(`Skipping invalid data entry:`, entry);
+                continue;
+            }
+
+            const repo = ctx.object(objectName);
+            
+            for (const record of records) {
+                try {
+                    // Check existence if a unique key is provided?
+                    // For now, let's assume if it has an ID, we check it.
+                    // Or we could try to find existing record by some key matching logic.
+                    // Simple approach: create. If it fails (constraint), ignore.
+                    
+                    // Actually, a better approach for initial data is "upsert" or "create if not exists".
+                    // But without unique keys defined in data, we can't reliably dedup.
+                    // Let's try to 'create' and catch errors.
+                    await repo.create(record);
+                    console.log(`Initialized record for ${objectName}`);
+                } catch (e: any) {
+                    // Ignore duplicate key errors silently-ish
+                     console.warn(`Failed to insert initial data for ${objectName}: ${e.message}`);
+                }
+            }
+        }
     }
 }

package/src/index.ts

@@ -1,9 +1,10 @@
-export * from './loader';
 export * from './repository';
 export * from './app';
-export * from './plugin';
-export * from './driver';
-export * from './remote';
+
 export * from './action';
 export * from './hook';
 export * from './object';
+export * from './validator';
+export * from './util';
+
+export * from './util';

package/src/util.ts

@@ -0,0 +1,5 @@
+export function toTitleCase(str: string): string {
+    return str
+        .replace(/_/g, ' ')
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+}