@objectql/core 1.1.0 → 1.3.0

package/src/driver.ts

@@ -1,24 +1,54 @@
-export interface Driver {
-    find(objectName: string, query: any, options?: any): Promise<any[]>;
-    findOne(objectName: string, id: string | number, query?: any, options?: any): Promise<any>;
-    create(objectName: string, data: any, options?: any): Promise<any>;
-    update(objectName: string, id: string | number, data: any, options?: any): Promise<any>;
-    delete(objectName: string, id: string | number, options?: any): Promise<any>;
-    count(objectName: string, filters: any, options?: any): Promise<number>;
-    
-    // Advanced
-    aggregate?(objectName: string, query: any, options?: any): Promise<any>;
-    distinct?(objectName: string, field: string, filters?: any, options?: any): Promise<any[]>;
+import { Driver } from '@objectql/types';
+
+export function createDriverFromConnection(connection: string): Driver {
+    let driverPackage = '';
+    let driverClass = '';
+    let driverConfig: any = {};
     
-    // Bulk / Atomic
-    createMany?(objectName: string, data: any[], options?: any): Promise<any>;
-    updateMany?(objectName: string, filters: any, data: any, options?: any): Promise<any>;
-    deleteMany?(objectName: string, filters: any, options?: any): Promise<any>;
-    findOneAndUpdate?(objectName: string, filters: any, update: any, options?: any): Promise<any>;
+    if (connection.startsWith('mongodb://')) {
+        driverPackage = '@objectql/driver-mongo';
+        driverClass = 'MongoDriver';
+        driverConfig = { url: connection };
+    } 
+    else if (connection.startsWith('sqlite://')) {
+        driverPackage = '@objectql/driver-knex';
+        driverClass = 'KnexDriver';
+        const filename = connection.replace('sqlite://', '');
+        driverConfig = {
+            client: 'sqlite3',
+            connection: { filename },
+            useNullAsDefault: true
+        };
+    }
+    else if (connection.startsWith('postgres://') || connection.startsWith('postgresql://')) {
+        driverPackage = '@objectql/driver-knex';
+        driverClass = 'KnexDriver';
+        driverConfig = {
+            client: 'pg',
+            connection: connection
+        };
+    }
+    else if (connection.startsWith('mysql://')) {
+        driverPackage = '@objectql/driver-knex';
+        driverClass = 'KnexDriver';
+        driverConfig = {
+            client: 'mysql2',
+            connection: connection
+        };
+    }
+    else {
+        throw new Error(`Unsupported connection protocol: ${connection}`);
+    }
 
-    // Transaction
-    beginTransaction?(): Promise<any>;
-    commitTransaction?(trx: any): Promise<void>;
-    rollbackTransaction?(trx: any): Promise<void>;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require(driverPackage);
+        const DriverClass = pkg[driverClass];
+        if (!DriverClass) {
+            throw new Error(`${driverClass} not found in ${driverPackage}`);
+        }
+        return new DriverClass(driverConfig);
+    } catch (e: any) {
+        throw new Error(`Failed to load driver ${driverPackage}. Please install it: npm install ${driverPackage}. Error: ${e.message}`);
+    }
 }
-

package/src/hook.ts

@@ -0,0 +1,42 @@
+import { HookContext, HookHandler, HookName, MetadataRegistry } from '@objectql/types';
+
+export interface HookEntry {
+    objectName: string;
+    handler: HookHandler;
+    packageName?: string;
+}
+
+export function registerHookHelper(
+    hooks: Record<string, HookEntry[]>,
+    event: HookName,
+    objectName: string,
+    handler: HookHandler,
+    packageName?: string
+) {
+    if (!hooks[event]) {
+        hooks[event] = [];
+    }
+    hooks[event].push({ objectName, handler, packageName });
+}
+
+export async function triggerHookHelper(
+    metadata: MetadataRegistry,
+    runtimeHooks: Record<string, HookEntry[]>,
+    event: HookName,
+    objectName: string,
+    ctx: HookContext
+) {
+    // 1. Registry Hooks (File-based)
+    const fileHooks = metadata.get<any>('hook', objectName);
+    if (fileHooks && typeof fileHooks[event] === 'function') {
+        await fileHooks[event](ctx);
+    }
+
+    // 2. Programmatic Hooks
+    const hooks = runtimeHooks[event] || [];
+    for (const hook of hooks) {
+        if (hook.objectName === '*' || hook.objectName === objectName) {
+            await hook.handler(ctx);
+        }
+    }
+}

package/src/index.ts

@@ -1,159 +1,9 @@
-import * as path from 'path';
-
-export * from './metadata';
-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 { MetadataLoader } from './loader';
-import { MetadataRegistry } from './registry';
-
-export class ObjectQL implements IObjectQL {
-    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);
-            }
-        }
-        if (config.packages) {
-            for (const name of config.packages) {
-                this.addPackage(name);
-            }
-        }
-    }
-
-    addPackage(name: string) {
-        this.loader.loadPackage(name);
-    }
-
-
-    removePackage(name: string) {
-        this.metadata.unregisterPackage(name);
-    }
-
-    loadFromDirectory(dir: string, packageName?: string) {
-        this.loader.load(dir, packageName);
-    }
-
-    createContext(options: ObjectQLContextOptions): ObjectQLContext {
-        const ctx: ObjectQLContext = {
-            userId: options.userId,
-            spaceId: options.spaceId,
-            roles: options.roles || [],
-            isSystem: options.isSystem,
-            ignoreTriggers: options.ignoreTriggers,
-            object: (name: string) => {
-                return new ObjectRepository(name, ctx, this);
-            },
-            transaction: async (callback) => {
-                 const driver = this.datasources['default'];
-                 if (!driver || !driver.beginTransaction) {
-                      return callback(ctx);
-                 }
-
-                 let trx: any;
-                 try {
-                     trx = await driver.beginTransaction();
-                 } catch (e) {
-                     throw e;
-                 }
-
-                 const trxCtx: ObjectQLContext = {
-                     ...ctx,
-                     transactionHandle: trx,
-                     transaction: async (cb) => cb(trxCtx)
-                 };
-
-                 try {
-                     const result = await callback(trxCtx);
-                     if (driver.commitTransaction) await driver.commitTransaction(trx);
-                     return result;
-                 } catch (error) {
-                     if (driver.rollbackTransaction) await driver.rollbackTransaction(trx);
-                     throw error;
-                 }
-            },
-            sudo: () => {
-                 return this.createContext({ ...options, isSystem: true });
-            }
-        };
-        return ctx;
-    }
-
-    registerObject(object: ObjectConfig) {
-        // Normalize fields
-        if (object.fields) {
-            for (const [key, field] of Object.entries(object.fields)) {
-                if (!field.name) {
-                    field.name = key;
-                }
-            }
-        }
-        this.metadata.register('object', {
-            type: 'object',
-            id: object.name,
-            content: object
-        });
-    }
-
-    getObject(name: string): ObjectConfig | undefined {
-        return this.metadata.get<ObjectConfig>('object', name);
-    }
-
-    getConfigs(): Record<string, ObjectConfig> {
-        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 {
-        const driver = this.datasources[name];
-        if (!driver) {
-            throw new Error(`Datasource '${name}' not found`);
-        }
-        return driver;
-    }
-
-    async init() {
-        const ctx = this.createContext({ isSystem: true });
-        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 ${obj.name}...`);
-                const repo = ctx.object(obj.name);
-                for (const record of obj.data) {
-                    try {
-                        if (record._id) {
-                             const existing = await repo.findOne(record._id);
-                             if (existing) {
-                                 continue;
-                             }
-                        }
-                        await repo.create(record);
-                        console.log(`Inserted init data for ${obj.name}: ${record._id || 'unknown id'}`);
-                    } catch (e) {
-                        console.error(`Failed to insert init data for ${obj.name}:`, e);
-                    }
-                }
-            }
-        }
-    }
-}
+export * from './repository';
+export * from './app';
+export * from './plugin';
+export * from './driver';
+export * from './remote';
+export * from './action';
+export * from './hook';
+export * from './object';

package/src/loader.ts

@@ -1,22 +1,197 @@
-import { MetadataRegistry } from './registry';
-import { ObjectConfig } from './types';
-import { MetadataLoader as BaseLoader, registerObjectQLPlugins } from '@objectql/metadata';
+import * as fs from 'fs';
+import * as glob from 'fast-glob';
+import * as path from 'path';
+import { MetadataRegistry, ObjectConfig, LoaderPlugin, LoaderHandlerContext } from '@objectql/types';
+import * as yaml from 'js-yaml';
 
-export class MetadataLoader extends BaseLoader {
-    constructor(registry: MetadataRegistry) {
-        super(registry);
-        registerObjectQLPlugins(this);
+export class ObjectLoader {
+    private plugins: LoaderPlugin[] = [];
+
+    constructor(protected registry: MetadataRegistry) {
+        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);
+                }
+            }
+        });
+
+        // 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);
+
+                    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
+                        });
+                    }
+
+                } catch (e) {
+                    console.error(`Error loading action from ${ctx.file}:`, e);
+                }
+            }
+        });
+    }
+
+    use(plugin: LoaderPlugin) {
+        this.plugins.push(plugin);
+    }
+
+    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) {
+            // fallback to directory
+            this.load(packageName, packageName);
+        }
     }
+
+    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);
+            }
+        }
+    }
+}
+
+function registerObject(registry: MetadataRegistry, 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;
+                }
+            }
+        }
+    }
+    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 MetadataRegistry();
-    const loader = new MetadataLoader(registry);
+    const loader = new ObjectLoader(registry);
     loader.load(dir);
+
+    // Merge actions into objects
+    const actions = registry.list<any>('action');
+    for (const act of actions) {
+        const obj = registry.get<ObjectConfig>('object', act.id);
+        if (obj) {
+            obj.actions = act.content;
+        }
+    }
+
     const result: Record<string, ObjectConfig> = {};
     for (const obj of registry.list<ObjectConfig>('object')) {
         result[obj.name] = obj;
     }
     return result;
 }
-

package/src/object.ts

@@ -0,0 +1,26 @@
+import { ObjectConfig, MetadataRegistry } from '@objectql/types';
+
+export function registerObjectHelper(metadata: MetadataRegistry, object: ObjectConfig) {
+    // Normalize fields
+    if (object.fields) {
+        for (const [key, field] of Object.entries(object.fields)) {
+            if (!field.name) {
+                field.name = key;
+            }
+        }
+    }
+    metadata.register('object', {
+        type: 'object',
+        id: object.name,
+        content: object
+    });
+}
+
+export function getConfigsHelper(metadata: MetadataRegistry): Record<string, ObjectConfig> {
+    const result: Record<string, ObjectConfig> = {};
+    const objects = metadata.list<ObjectConfig>('object');
+    for (const obj of objects) {
+        result[obj.name] = obj;
+    }
+    return result;
+}

package/src/plugin.ts

@@ -0,0 +1,53 @@
+import { ObjectQLPlugin } from '@objectql/types';
+
+export function loadPlugin(packageName: string): ObjectQLPlugin {
+    let mod: any;
+    try {
+        const modulePath = require.resolve(packageName, { paths: [process.cwd()] });
+        mod = require(modulePath);
+    } catch (e) {
+        throw new Error(`Failed to resolve plugin '${packageName}': ${e}`);
+    }
+
+    // Helper to find plugin instance
+    const findPlugin = (candidate: any): ObjectQLPlugin | undefined => {
+            if (!candidate) return undefined;
+            
+            // 1. Try treating as Class
+            if (typeof candidate === 'function') {
+                try {
+                    const inst = new candidate();
+                    if (inst && typeof inst.setup === 'function') {
+                        return inst; // Found it!
+                    }
+                } catch (e) {
+                    // Not a constructor or instantiation failed
+                }
+            }
+
+            // 2. Try treating as Instance
+            if (candidate && typeof candidate.setup === 'function') {
+                if (candidate.name) return candidate;
+            }
+            return undefined;
+    };
+
+    // Search in default, module root, and all named exports
+    let instance = findPlugin(mod.default) || findPlugin(mod);
+    
+    if (!instance && mod && typeof mod === 'object') {
+        for (const key of Object.keys(mod)) {
+            if (key === 'default') continue;
+            instance = findPlugin(mod[key]);
+            if (instance) break;
+        }
+    }
+
+    if (instance) {
+        (instance as any)._packageName = packageName;
+        return instance;
+    } else {
+        console.error(`[PluginLoader] Failed to find ObjectQLPlugin in '${packageName}'. Exports:`, Object.keys(mod));
+        throw new Error(`Plugin '${packageName}' must export a class or object implementing ObjectQLPlugin.`);
+    }
+}

package/src/remote.ts

@@ -0,0 +1,50 @@
+import { RemoteDriver } from '@objectql/driver-remote';
+import { ObjectConfig } from '@objectql/types';
+
+export interface RemoteLoadResult {
+    driverName: string;
+    driver: RemoteDriver;
+    objects: ObjectConfig[];
+}
+
+export async function loadRemoteFromUrl(url: string): Promise<RemoteLoadResult | null> {
+    try {
+        const baseUrl = url.replace(/\/$/, '');
+        const metadataUrl = `${baseUrl}/api/metadata/objects`;
+        
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - Fetch is available in Node 18+
+        const res = await fetch(metadataUrl);
+        if (!res.ok) {
+            console.warn(`[ObjectQL] Remote ${url} returned ${res.status}`);
+            return null;
+        }
+
+        const data = await res.json() as any;
+        if (!data || !data.objects) return null;
+
+        const driverName = `remote:${baseUrl}`;
+        const driver = new RemoteDriver(baseUrl);
+        const objects: ObjectConfig[] = [];
+
+        await Promise.all(data.objects.map(async (summary: any) => {
+            try {
+                // @ts-ignore
+                const detailRes = await fetch(`${metadataUrl}/${summary.name}`);
+                if (detailRes.ok) {
+                    const config = await detailRes.json() as ObjectConfig;
+                    config.datasource = driverName;
+                    objects.push(config);
+                }
+            } catch (e) {
+                console.warn(`[ObjectQL] Failed to load object ${summary.name} from ${url}`);
+            }
+        }));
+
+        return { driverName, driver, objects };
+
+    } catch (e: any) {
+         console.warn(`[ObjectQL] Remote connection error ${url}: ${e.message}`);
+         return null;
+    }
+}