@objectstack/objectql 0.6.0 → 0.7.1

package/dist/engine.js

@@ -0,0 +1,423 @@
+import { createLogger } from '@objectstack/core';
+import { SchemaRegistry } from './registry';
+/**
+ * ObjectQL Engine
+ *
+ * Implements the IDataEngine interface for data persistence.
+ */
+export class ObjectQL {
+    constructor(hostContext = {}) {
+        this.drivers = new Map();
+        this.defaultDriver = null;
+        // Hooks Registry
+        this.hooks = {
+            'beforeFind': [], 'afterFind': [],
+            'beforeInsert': [], 'afterInsert': [],
+            'beforeUpdate': [], 'afterUpdate': [],
+            'beforeDelete': [], 'afterDelete': [],
+        };
+        // Host provided context additions (e.g. Server router)
+        this.hostContext = {};
+        this.hostContext = hostContext;
+        // Use provided logger or create a new one
+        this.logger = hostContext.logger || createLogger({ level: 'info', format: 'pretty' });
+        this.logger.info('ObjectQL Engine Instance Created');
+    }
+    /**
+     * Load and Register a Plugin
+     */
+    async use(manifestPart, runtimePart) {
+        this.logger.debug('Loading plugin', {
+            hasManifest: !!manifestPart,
+            hasRuntime: !!runtimePart
+        });
+        // 1. Validate / Register Manifest
+        if (manifestPart) {
+            this.registerApp(manifestPart);
+        }
+        // 2. Execute Runtime
+        if (runtimePart) {
+            const pluginDef = runtimePart.default || runtimePart;
+            if (pluginDef.onEnable) {
+                this.logger.debug('Executing plugin runtime onEnable');
+                const context = {
+                    ql: this,
+                    logger: this.logger,
+                    // Expose the driver registry helper explicitly if needed
+                    drivers: {
+                        register: (driver) => this.registerDriver(driver)
+                    },
+                    ...this.hostContext
+                };
+                await pluginDef.onEnable(context);
+                this.logger.debug('Plugin runtime onEnable completed');
+            }
+        }
+    }
+    /**
+     * Register a hook
+     * @param event The event name (e.g. 'beforeFind', 'afterInsert')
+     * @param handler The handler function
+     */
+    registerHook(event, handler) {
+        if (!this.hooks[event]) {
+            this.hooks[event] = [];
+        }
+        this.hooks[event].push(handler);
+        this.logger.debug('Registered hook', { event, totalHandlers: this.hooks[event].length });
+    }
+    async triggerHooks(event, context) {
+        const handlers = this.hooks[event] || [];
+        if (handlers.length === 0) {
+            this.logger.debug('No hooks registered for event', { event });
+            return;
+        }
+        this.logger.debug('Triggering hooks', { event, count: handlers.length });
+        for (const handler of handlers) {
+            await handler(context);
+        }
+    }
+    /**
+     * Register contribution (Manifest)
+     */
+    registerApp(manifest) {
+        const id = manifest.id;
+        this.logger.debug('Registering app manifest', { id });
+        // Register objects
+        if (manifest.objects) {
+            if (Array.isArray(manifest.objects)) {
+                this.logger.debug('Registering objects from manifest (Array)', { id, objectCount: manifest.objects.length });
+                for (const objDef of manifest.objects) {
+                    SchemaRegistry.registerObject(objDef);
+                    this.logger.debug('Registered Object', { object: objDef.name, from: id });
+                }
+            }
+            else {
+                this.logger.debug('Registering objects from manifest (Map)', { id, objectCount: Object.keys(manifest.objects).length });
+                for (const [name, objDef] of Object.entries(manifest.objects)) {
+                    // Ensure name in definition matches key
+                    objDef.name = name;
+                    SchemaRegistry.registerObject(objDef);
+                    this.logger.debug('Registered Object', { object: name, from: id });
+                }
+            }
+        }
+        // Register contributions
+        if (manifest.contributes?.kinds) {
+            this.logger.debug('Registering kinds from manifest', { id, kindCount: manifest.contributes.kinds.length });
+            for (const kind of manifest.contributes.kinds) {
+                SchemaRegistry.registerKind(kind);
+                this.logger.debug('Registered Kind', { kind: kind.name || kind.type, from: id });
+            }
+        }
+    }
+    /**
+     * Register a new storage driver
+     */
+    registerDriver(driver, isDefault = false) {
+        if (this.drivers.has(driver.name)) {
+            this.logger.warn('Driver already registered, skipping', { driverName: driver.name });
+            return;
+        }
+        this.drivers.set(driver.name, driver);
+        this.logger.info('Registered driver', {
+            driverName: driver.name,
+            version: driver.version
+        });
+        if (isDefault || this.drivers.size === 1) {
+            this.defaultDriver = driver.name;
+            this.logger.info('Set default driver', { driverName: driver.name });
+        }
+    }
+    /**
+     * Helper to get object definition
+     */
+    getSchema(objectName) {
+        return SchemaRegistry.getObject(objectName);
+    }
+    /**
+     * Helper to get the target driver
+     */
+    getDriver(objectName) {
+        const object = SchemaRegistry.getObject(objectName);
+        // 1. If object definition exists, check for explicit datasource
+        if (object) {
+            const datasourceName = object.datasource || 'default';
+            // If configured for 'default', try to find the default driver
+            if (datasourceName === 'default') {
+                if (this.defaultDriver && this.drivers.has(this.defaultDriver)) {
+                    return this.drivers.get(this.defaultDriver);
+                }
+            }
+            else {
+                // Specific datasource requested
+                if (this.drivers.has(datasourceName)) {
+                    return this.drivers.get(datasourceName);
+                }
+                throw new Error(`[ObjectQL] Datasource '${datasourceName}' configured for object '${objectName}' is not registered.`);
+            }
+        }
+        // 2. Fallback for ad-hoc objects or missing definitions
+        if (this.defaultDriver) {
+            return this.drivers.get(this.defaultDriver);
+        }
+        throw new Error(`[ObjectQL] No driver available for object '${objectName}'`);
+    }
+    /**
+     * Initialize the engine and all registered drivers
+     */
+    async init() {
+        this.logger.info('Initializing ObjectQL engine', {
+            driverCount: this.drivers.size,
+            drivers: Array.from(this.drivers.keys())
+        });
+        for (const [name, driver] of this.drivers) {
+            try {
+                await driver.connect();
+                this.logger.info('Driver connected successfully', { driverName: name });
+            }
+            catch (e) {
+                this.logger.error('Failed to connect driver', e, { driverName: name });
+            }
+        }
+        this.logger.info('ObjectQL engine initialization complete');
+    }
+    async destroy() {
+        this.logger.info('Destroying ObjectQL engine', { driverCount: this.drivers.size });
+        for (const [name, driver] of this.drivers.entries()) {
+            try {
+                await driver.disconnect();
+            }
+            catch (e) {
+                this.logger.error('Error disconnecting driver', e, { driverName: name });
+            }
+        }
+        this.logger.info('ObjectQL engine destroyed');
+    }
+    // ============================================
+    // Helper: Query Conversion
+    // ============================================
+    toQueryAST(object, options) {
+        const ast = { object };
+        if (!options)
+            return ast;
+        if (options.filter) {
+            ast.where = options.filter;
+        }
+        if (options.select) {
+            ast.fields = options.select;
+        }
+        if (options.sort) {
+            // Support DataEngineSortSchema variant
+            if (Array.isArray(options.sort)) {
+                // [{ field: 'a', order: 'asc' }]
+                ast.orderBy = options.sort;
+            }
+            else {
+                // Record<string, 'asc' | 'desc' | 1 | -1>
+                ast.orderBy = Object.entries(options.sort).map(([field, order]) => ({
+                    field,
+                    order: (order === -1 || order === 'desc') ? 'desc' : 'asc'
+                }));
+            }
+        }
+        if (options.top !== undefined)
+            ast.limit = options.top;
+        else if (options.limit !== undefined)
+            ast.limit = options.limit;
+        if (options.skip !== undefined)
+            ast.offset = options.skip;
+        // TODO: Handle populate/joins mapping if Driver supports it in QueryAST
+        return ast;
+    }
+    // ============================================
+    // Data Access Methods (IDataEngine Interface)
+    // ============================================
+    async find(object, query) {
+        this.logger.debug('Find operation starting', { object, query });
+        const driver = this.getDriver(object);
+        const ast = this.toQueryAST(object, query);
+        const hookContext = {
+            object,
+            event: 'beforeFind',
+            input: { ast, options: undefined }, // Should map options?
+            ql: this
+        };
+        await this.triggerHooks('beforeFind', hookContext);
+        try {
+            const result = await driver.find(object, hookContext.input.ast, hookContext.input.options);
+            hookContext.event = 'afterFind';
+            hookContext.result = result;
+            await this.triggerHooks('afterFind', hookContext);
+            return hookContext.result;
+        }
+        catch (e) {
+            this.logger.error('Find operation failed', e, { object });
+            throw e;
+        }
+    }
+    async findOne(objectName, query) {
+        this.logger.debug('FindOne operation', { objectName });
+        const driver = this.getDriver(objectName);
+        const ast = this.toQueryAST(objectName, query);
+        ast.limit = 1;
+        // Reuse find logic or call generic driver.findOne if available
+        // Assuming driver has findOne
+        return driver.findOne(objectName, ast);
+    }
+    async insert(object, data, options) {
+        this.logger.debug('Insert operation starting', { object, isBatch: Array.isArray(data) });
+        const driver = this.getDriver(object);
+        const hookContext = {
+            object,
+            event: 'beforeInsert',
+            input: { data, options },
+            ql: this
+        };
+        await this.triggerHooks('beforeInsert', hookContext);
+        try {
+            let result;
+            if (Array.isArray(hookContext.input.data)) {
+                // Bulk Create
+                if (driver.bulkCreate) {
+                    result = await driver.bulkCreate(object, hookContext.input.data, hookContext.input.options);
+                }
+                else {
+                    // Fallback loop
+                    result = await Promise.all(hookContext.input.data.map((item) => driver.create(object, item, hookContext.input.options)));
+                }
+            }
+            else {
+                result = await driver.create(object, hookContext.input.data, hookContext.input.options);
+            }
+            hookContext.event = 'afterInsert';
+            hookContext.result = result;
+            await this.triggerHooks('afterInsert', hookContext);
+            return hookContext.result;
+        }
+        catch (e) {
+            this.logger.error('Insert operation failed', e, { object });
+            throw e;
+        }
+    }
+    async update(object, data, options) {
+        // NOTE: This signature is tricky because Driver expects (obj, id, data) usually.
+        // DataEngine protocol puts filter in options.
+        this.logger.debug('Update operation starting', { object });
+        const driver = this.getDriver(object);
+        // 1. Extract ID from data or filter if it's a single update by ID
+        // This is a simplification. Real implementation needs robust filter handling.
+        let id = data.id || data._id;
+        if (!id && options?.filter) {
+            // Optimization: If filter is simple ID check, extract it
+            if (typeof options.filter === 'string')
+                id = options.filter;
+            else if (options.filter._id)
+                id = options.filter._id;
+            else if (options.filter.id)
+                id = options.filter.id;
+        }
+        const hookContext = {
+            object,
+            event: 'beforeUpdate',
+            input: { id, data, options },
+            ql: this
+        };
+        await this.triggerHooks('beforeUpdate', hookContext);
+        try {
+            let result;
+            if (hookContext.input.id) {
+                // Single update by ID
+                result = await driver.update(object, hookContext.input.id, hookContext.input.data, hookContext.input.options);
+            }
+            else if (options?.multi && driver.updateMany) {
+                // Bulk update by Query
+                const ast = this.toQueryAST(object, { filter: options.filter });
+                result = await driver.updateMany(object, ast, hookContext.input.data, hookContext.input.options);
+            }
+            else {
+                throw new Error('Update requires an ID or options.multi=true');
+            }
+            hookContext.event = 'afterUpdate';
+            hookContext.result = result;
+            await this.triggerHooks('afterUpdate', hookContext);
+            return hookContext.result;
+        }
+        catch (e) {
+            this.logger.error('Update operation failed', e, { object });
+            throw e;
+        }
+    }
+    async delete(object, options) {
+        this.logger.debug('Delete operation starting', { object });
+        const driver = this.getDriver(object);
+        // Extract ID logic similar to update
+        let id = undefined;
+        if (options?.filter) {
+            if (typeof options.filter === 'string')
+                id = options.filter;
+            else if (options.filter._id)
+                id = options.filter._id;
+            else if (options.filter.id)
+                id = options.filter.id;
+        }
+        const hookContext = {
+            object,
+            event: 'beforeDelete',
+            input: { id, options },
+            ql: this
+        };
+        await this.triggerHooks('beforeDelete', hookContext);
+        try {
+            let result;
+            if (hookContext.input.id) {
+                result = await driver.delete(object, hookContext.input.id, hookContext.input.options);
+            }
+            else if (options?.multi && driver.deleteMany) {
+                const ast = this.toQueryAST(object, { filter: options.filter });
+                result = await driver.deleteMany(object, ast, hookContext.input.options);
+            }
+            else {
+                throw new Error('Delete requires an ID or options.multi=true');
+            }
+            hookContext.event = 'afterDelete';
+            hookContext.result = result;
+            await this.triggerHooks('afterDelete', hookContext);
+            return hookContext.result;
+        }
+        catch (e) {
+            this.logger.error('Delete operation failed', e, { object });
+            throw e;
+        }
+    }
+    async count(object, query) {
+        const driver = this.getDriver(object);
+        if (driver.count) {
+            const ast = this.toQueryAST(object, { filter: query?.filter });
+            return driver.count(object, ast);
+        }
+        // Fallback to find().length
+        const res = await this.find(object, { filter: query?.filter, select: ['_id'] });
+        return res.length;
+    }
+    async aggregate(object, query) {
+        const driver = this.getDriver(object);
+        this.logger.debug(`Aggregate on ${object} using ${driver.name}`, query);
+        // Driver needs support for raw aggregation or mapped aggregation
+        // For now, if driver supports 'execute', we might pass it down, or we need to add 'aggregate' to DriverInterface
+        // In this version, we'll assume driver might handle it via special 'find' or throw not implemented
+        throw new Error('Aggregate not yet fully implemented in ObjectQL->Driver mapping');
+    }
+    async execute(command, options) {
+        // Direct pass-through implies we know which driver to use?
+        // Usually execute is tied to a specific object context OR we need a way to select driver.
+        // If command has 'object', we use that.
+        if (options?.object) {
+            const driver = this.getDriver(options.object);
+            if (driver.execute) {
+                return driver.execute(command, undefined, options);
+            }
+        }
+        throw new Error('Execute requires options.object to select driver');
+    }
+}

package/dist/index.d.ts

@@ -1,199 +1,6 @@
-import { HookContext } from '@objectstack/spec/data';
-import { DriverOptions } from '@objectstack/spec/system';
-import { DriverInterface, IDataEngine, DataEngineQueryOptions } from '@objectstack/core';
 export { SchemaRegistry } from './registry';
 export { ObjectStackProtocolImplementation } from './protocol';
-export type HookHandler = (context: HookContext) => Promise<void> | void;
-/**
- * Host Context provided to plugins
- */
-export interface PluginContext {
-    ql: ObjectQL;
-    logger: Console;
-    [key: string]: any;
-}
-/**
- * ObjectQL Engine
- *
- * Implements the IDataEngine interface for data persistence.
- */
-export declare class ObjectQL implements IDataEngine {
-    private drivers;
-    private defaultDriver;
-    private hooks;
-    private hostContext;
-    constructor(hostContext?: Record<string, any>);
-    /**
-     * Load and Register a Plugin
-     */
-    use(manifestPart: any, runtimePart?: any): Promise<void>;
-    /**
-     * Register a hook
-     * @param event The event name (e.g. 'beforeFind', 'afterInsert')
-     * @param handler The handler function
-     */
-    registerHook(event: string, handler: HookHandler): void;
-    private triggerHooks;
-    registerApp(manifestPart: any): void;
-    /**
-     * Register a new storage driver
-     */
-    registerDriver(driver: DriverInterface, isDefault?: boolean): void;
-    /**
-     * Helper to get object definition
-     */
-    getSchema(objectName: string): {
-        fields: Record<string, {
-            type: "number" | "boolean" | "code" | "date" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "richtext" | "currency" | "percent" | "datetime" | "time" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "file" | "avatar" | "video" | "audio" | "formula" | "summary" | "autonumber" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector";
-            required: boolean;
-            searchable: boolean;
-            multiple: boolean;
-            unique: boolean;
-            deleteBehavior: "set_null" | "cascade" | "restrict";
-            hidden: boolean;
-            readonly: boolean;
-            encryption: boolean;
-            index: boolean;
-            externalId: boolean;
-            options?: {
-                value: string;
-                label: string;
-                color?: string | undefined;
-                default?: boolean | undefined;
-            }[] | undefined;
-            min?: number | undefined;
-            max?: number | undefined;
-            formula?: string | undefined;
-            label?: string | undefined;
-            precision?: number | undefined;
-            name?: string | undefined;
-            description?: string | undefined;
-            format?: string | undefined;
-            defaultValue?: any;
-            maxLength?: number | undefined;
-            minLength?: number | undefined;
-            scale?: number | undefined;
-            reference?: string | undefined;
-            referenceFilters?: string[] | undefined;
-            writeRequiresMasterRead?: boolean | undefined;
-            expression?: string | undefined;
-            summaryOperations?: {
-                object: string;
-                function: "count" | "sum" | "avg" | "min" | "max";
-                field: string;
-            } | undefined;
-            language?: string | undefined;
-            theme?: string | undefined;
-            lineNumbers?: boolean | undefined;
-            maxRating?: number | undefined;
-            allowHalf?: boolean | undefined;
-            displayMap?: boolean | undefined;
-            allowGeocoding?: boolean | undefined;
-            addressFormat?: "us" | "uk" | "international" | undefined;
-            colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | undefined;
-            allowAlpha?: boolean | undefined;
-            presetColors?: string[] | undefined;
-            step?: number | undefined;
-            showValue?: boolean | undefined;
-            marks?: Record<string, string> | undefined;
-            barcodeFormat?: "qr" | "ean13" | "ean8" | "code128" | "code39" | "upca" | "upce" | undefined;
-            qrErrorCorrection?: "L" | "M" | "Q" | "H" | undefined;
-            displayValue?: boolean | undefined;
-            allowScanning?: boolean | undefined;
-            currencyConfig?: {
-                precision: number;
-                currencyMode: "dynamic" | "fixed";
-                defaultCurrency: string;
-            } | undefined;
-            vectorConfig?: {
-                dimensions: number;
-                distanceMetric: "cosine" | "euclidean" | "dotProduct" | "manhattan";
-                normalized: boolean;
-                indexed: boolean;
-                indexType?: "flat" | "hnsw" | "ivfflat" | undefined;
-            } | undefined;
-        }>;
-        name: string;
-        active: boolean;
-        isSystem: boolean;
-        abstract: boolean;
-        datasource: string;
-        tags?: string[] | undefined;
-        label?: string | undefined;
-        description?: string | undefined;
-        search?: {
-            fields: string[];
-            displayFields?: string[] | undefined;
-            filters?: string[] | undefined;
-        } | undefined;
-        pluralLabel?: string | undefined;
-        icon?: string | undefined;
-        tableName?: string | undefined;
-        indexes?: {
-            fields: string[];
-            type?: "hash" | "btree" | "gin" | "gist" | undefined;
-            name?: string | undefined;
-            unique?: boolean | undefined;
-        }[] | undefined;
-        validations?: any[] | undefined;
-        titleFormat?: string | undefined;
-        compactLayout?: string[] | undefined;
-        enable?: {
-            searchable: boolean;
-            trackHistory: boolean;
-            apiEnabled: boolean;
-            files: boolean;
-            feeds: boolean;
-            activities: boolean;
-            trash: boolean;
-            mru: boolean;
-            clone: boolean;
-            apiMethods?: ("update" | "delete" | "get" | "list" | "create" | "upsert" | "bulk" | "aggregate" | "history" | "search" | "restore" | "purge" | "import" | "export")[] | undefined;
-        } | undefined;
-    } | undefined;
-    /**
-     * Helper to get the target driver
-     */
-    private getDriver;
-    /**
-     * Initialize the engine and all registered drivers
-     */
-    init(): Promise<void>;
-    destroy(): Promise<void>;
-    /**
-     * Find records matching a query (IDataEngine interface)
-     *
-     * @param object - Object name
-     * @param query - Query options (IDataEngine format)
-     * @returns Promise resolving to array of records
-     */
-    find(object: string, query?: DataEngineQueryOptions): Promise<any[]>;
-    findOne(object: string, idOrQuery: string | any, options?: DriverOptions): Promise<any>;
-    /**
-     * Insert a new record (IDataEngine interface)
-     *
-     * @param object - Object name
-     * @param data - Data to insert
-     * @returns Promise resolving to the created record
-     */
-    insert(object: string, data: any): Promise<any>;
-    /**
-     * Update a record by ID (IDataEngine interface)
-     *
-     * @param object - Object name
-     * @param id - Record ID
-     * @param data - Updated data
-     * @returns Promise resolving to the updated record
-     */
-    update(object: string, id: any, data: any): Promise<any>;
-    /**
-     * Delete a record by ID (IDataEngine interface)
-     *
-     * @param object - Object name
-     * @param id - Record ID
-     * @returns Promise resolving to true if deleted, false otherwise
-     */
-    delete(object: string, id: any): Promise<boolean>;
-}
-export * from './plugin';
+export { ObjectQL } from './engine';
+export type { ObjectQLHostContext, HookHandler } from './engine';
+export { ObjectQLPlugin } from './plugin';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG5C,OAAO,EAAE,iCAAiC,EAAE,MAAM,YAAY,CAAC;AAG/D,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGjE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}