@object-ui/core 0.3.1 → 0.5.0

package/dist/query/query-ast.js

@@ -0,0 +1,268 @@
+/**
+ * ObjectUI - Query AST Builder
+ * Phase 3.3: QuerySchema AST implementation
+ * ObjectStack Spec v0.7.1: Window functions support
+ */
+/**
+ * Query AST Builder - Converts QuerySchema to AST
+ */
+export class QueryASTBuilder {
+    build(query) {
+        const ast = {
+            select: this.buildSelect(query),
+            from: this.buildFrom(query),
+        };
+        if (query.filter) {
+            ast.where = this.buildWhere(query.filter);
+        }
+        if (query.joins && query.joins.length > 0) {
+            ast.joins = query.joins.map(join => this.buildJoin(join));
+        }
+        if (query.group_by && query.group_by.length > 0) {
+            ast.group_by = this.buildGroupBy(query.group_by);
+        }
+        if (query.sort && query.sort.length > 0) {
+            ast.order_by = this.buildOrderBy(query.sort);
+        }
+        if (query.limit !== undefined) {
+            ast.limit = this.buildLimit(query.limit);
+        }
+        if (query.offset !== undefined) {
+            ast.offset = this.buildOffset(query.offset);
+        }
+        return ast;
+    }
+    buildSelect(query) {
+        const fields = [];
+        if (query.fields && query.fields.length > 0) {
+            fields.push(...query.fields.map(field => this.buildField(field)));
+        }
+        else if (!query.aggregations || query.aggregations.length === 0) {
+            // Only add '*' if there are no aggregations
+            fields.push(this.buildField('*'));
+        }
+        if (query.aggregations && query.aggregations.length > 0) {
+            fields.push(...query.aggregations.map(agg => this.buildAggregation(agg)));
+        }
+        // Add window functions (ObjectStack Spec v0.7.1)
+        if (query.windows && query.windows.length > 0) {
+            fields.push(...query.windows.map(win => this.buildWindow(win)));
+        }
+        return {
+            type: 'select',
+            fields,
+            distinct: false,
+        };
+    }
+    buildFrom(query) {
+        return {
+            type: 'from',
+            table: query.object,
+        };
+    }
+    buildWhere(filter) {
+        return {
+            type: 'where',
+            condition: this.buildFilterCondition(filter),
+        };
+    }
+    buildFilterCondition(filter) {
+        const operator = filter.operator || 'and';
+        const operands = [];
+        if (filter.conditions && filter.conditions.length > 0) {
+            operands.push(...filter.conditions.map(cond => this.buildCondition(cond)));
+        }
+        if (filter.groups && filter.groups.length > 0) {
+            operands.push(...filter.groups.map(group => this.buildFilterCondition(group)));
+        }
+        return {
+            type: 'operator',
+            operator: operator,
+            operands,
+        };
+    }
+    buildCondition(condition) {
+        const field = this.buildField(condition.field);
+        // Map filter operators to comparison operators
+        const operatorMap = {
+            'equals': '=',
+            'not_equals': '!=',
+            'greater_than': '>',
+            'greater_than_or_equal': '>=',
+            'less_than': '<',
+            'less_than_or_equal': '<=',
+            'contains': 'contains',
+            'not_contains': 'contains',
+            'starts_with': 'starts_with',
+            'ends_with': 'ends_with',
+            'like': 'like',
+            'ilike': 'ilike',
+            'in': 'in',
+            'not_in': 'not_in',
+            'is_null': 'is_null',
+            'is_not_null': 'is_not_null',
+            'between': 'between',
+        };
+        const operator = operatorMap[condition.operator] || '=';
+        // Handle special operators
+        if (operator === 'between' && condition.values && condition.values.length === 2) {
+            return {
+                type: 'operator',
+                operator: 'between',
+                operands: [
+                    field,
+                    this.buildLiteral(condition.values[0]),
+                    this.buildLiteral(condition.values[1])
+                ],
+            };
+        }
+        if ((operator === 'in' || operator === 'not_in') && condition.values) {
+            return {
+                type: 'operator',
+                operator: operator,
+                operands: [field, ...condition.values.map(v => this.buildLiteral(v))],
+            };
+        }
+        if (operator === 'is_null' || operator === 'is_not_null') {
+            return {
+                type: 'operator',
+                operator: operator,
+                operands: [field],
+            };
+        }
+        // Standard binary operator
+        const value = this.buildLiteral(condition.value);
+        return {
+            type: 'operator',
+            operator: operator,
+            operands: [field, value],
+        };
+    }
+    buildJoin(join) {
+        const onCondition = {
+            type: 'operator',
+            operator: '=',
+            operands: [
+                this.buildField(join.on.local_field),
+                this.buildField(join.on.foreign_field, join.alias || join.object),
+            ],
+        };
+        return {
+            type: 'join',
+            join_type: join.type,
+            table: join.object,
+            alias: join.alias,
+            on: onCondition,
+        };
+    }
+    buildGroupBy(fields) {
+        return {
+            type: 'group_by',
+            fields: fields.map(field => this.buildField(field)),
+        };
+    }
+    buildOrderBy(sorts) {
+        return {
+            type: 'order_by',
+            fields: sorts.map(sort => ({
+                field: this.buildField(sort.field),
+                direction: sort.order,
+            })),
+        };
+    }
+    buildLimit(limit) {
+        return {
+            type: 'limit',
+            value: limit,
+        };
+    }
+    buildOffset(offset) {
+        return {
+            type: 'offset',
+            value: offset,
+        };
+    }
+    buildField(field, table) {
+        const parts = field.split('.');
+        if (parts.length === 2) {
+            return {
+                type: 'field',
+                table: parts[0],
+                name: parts[1],
+            };
+        }
+        return {
+            type: 'field',
+            table,
+            name: field,
+        };
+    }
+    buildLiteral(value) {
+        let dataType = 'string';
+        if (value === null || value === undefined) {
+            dataType = 'null';
+        }
+        else if (typeof value === 'number') {
+            dataType = 'number';
+        }
+        else if (typeof value === 'boolean') {
+            dataType = 'boolean';
+        }
+        else if (value instanceof Date) {
+            dataType = 'date';
+        }
+        return {
+            type: 'literal',
+            value,
+            data_type: dataType,
+        };
+    }
+    buildAggregation(agg) {
+        return {
+            type: 'aggregate',
+            function: agg.function,
+            field: agg.field ? this.buildField(agg.field) : undefined,
+            alias: agg.alias,
+            distinct: agg.distinct,
+        };
+    }
+    /**
+     * Build window function node (ObjectStack Spec v0.7.1)
+     */
+    buildWindow(config) {
+        const node = {
+            type: 'window',
+            function: config.function,
+            alias: config.alias,
+        };
+        if (config.field) {
+            node.field = this.buildField(config.field);
+        }
+        if (config.partitionBy && config.partitionBy.length > 0) {
+            node.partitionBy = config.partitionBy.map(field => this.buildField(field));
+        }
+        if (config.orderBy && config.orderBy.length > 0) {
+            node.orderBy = config.orderBy.map(sort => ({
+                field: this.buildField(sort.field),
+                direction: sort.direction,
+            }));
+        }
+        if (config.frame) {
+            node.frame = config.frame;
+        }
+        if (config.offset !== undefined) {
+            node.offset = config.offset;
+        }
+        if (config.defaultValue !== undefined) {
+            node.defaultValue = this.buildLiteral(config.defaultValue);
+        }
+        return node;
+    }
+    optimize(ast) {
+        return ast;
+    }
+}
+export const defaultQueryASTBuilder = new QueryASTBuilder();
+export function buildQueryAST(query) {
+    return defaultQueryASTBuilder.build(query);
+}

package/dist/registry/PluginScopeImpl.d.ts

@@ -0,0 +1,80 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/core - Plugin Scope Implementation
+ *
+ * Section 3.3: Implementation of scoped plugin system to prevent conflicts.
+ * Provides isolated component registration, state management, and event bus.
+ *
+ * @module plugin-scope-impl
+ * @packageDocumentation
+ */
+import type { PluginScope, PluginScopeConfig, PluginEventHandler } from '@object-ui/types';
+import type { Registry } from './Registry.js';
+/**
+ * Plugin Scope Implementation
+ *
+ * Provides isolated access to registry, state, and events for each plugin.
+ */
+export declare class PluginScopeImpl implements PluginScope {
+    readonly name: string;
+    readonly version: string;
+    private registry;
+    private state;
+    private eventBus;
+    private config;
+    constructor(name: string, version: string, registry: Registry, config?: PluginScopeConfig);
+    /**
+     * Register a component in the scoped namespace
+     */
+    registerComponent(type: string, component: any, meta?: any): void;
+    /**
+     * Get a component from the scoped namespace
+     */
+    getComponent(type: string): any | undefined;
+    /**
+     * Scoped state management
+     */
+    useState<T>(key: string, initialValue: T): [T, (value: T | ((prev: T) => T)) => void];
+    /**
+     * Get scoped state value
+     */
+    getState<T>(key: string): T | undefined;
+    /**
+     * Set scoped state value
+     */
+    setState<T>(key: string, value: T): void;
+    /**
+     * Subscribe to scoped events
+     */
+    on(event: string, handler: PluginEventHandler): () => void;
+    /**
+     * Emit a scoped event
+     */
+    emit(event: string, data?: any): void;
+    /**
+     * Emit a global event
+     */
+    emitGlobal(event: string, data?: any): void;
+    /**
+     * Subscribe to global events
+     */
+    onGlobal(event: string, handler: PluginEventHandler): () => void;
+    /**
+     * Clean up all plugin resources
+     */
+    cleanup(): void;
+    /**
+     * Estimate total state size in bytes
+     */
+    private estimateStateSize;
+    /**
+     * Estimate size of a value in bytes
+     */
+    private estimateValueSize;
+}

package/dist/registry/PluginScopeImpl.js

@@ -0,0 +1,243 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Event Bus for scoped plugin events
+ */
+class EventBus {
+    constructor() {
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    on(event, handler) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(handler);
+        // Return unsubscribe function
+        return () => {
+            this.listeners.get(event)?.delete(handler);
+            if (this.listeners.get(event)?.size === 0) {
+                this.listeners.delete(event);
+            }
+        };
+    }
+    emit(event, data) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(data);
+                }
+                catch (error) {
+                    console.error(`Error in event handler for "${event}":`, error);
+                }
+            });
+        }
+    }
+    cleanup() {
+        this.listeners.clear();
+    }
+}
+/**
+ * Global event bus for cross-plugin communication
+ */
+const globalEventBus = new EventBus();
+/**
+ * Plugin Scope Implementation
+ *
+ * Provides isolated access to registry, state, and events for each plugin.
+ */
+export class PluginScopeImpl {
+    constructor(name, version, registry, config) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "registry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "eventBus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventBus()
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = name;
+        this.version = version;
+        this.registry = registry;
+        this.config = {
+            enableStateIsolation: config?.enableStateIsolation ?? true,
+            enableEventIsolation: config?.enableEventIsolation ?? true,
+            allowGlobalEvents: config?.allowGlobalEvents ?? true,
+            maxStateSize: config?.maxStateSize ?? 5 * 1024 * 1024, // 5MB
+        };
+    }
+    /**
+     * Register a component in the scoped namespace
+     */
+    registerComponent(type, component, meta) {
+        // Components are registered as "pluginName:type"
+        const registryMeta = {
+            ...meta,
+            namespace: this.name,
+        };
+        this.registry.register(type, component, registryMeta);
+    }
+    /**
+     * Get a component from the scoped namespace
+     */
+    getComponent(type) {
+        // First try scoped lookup
+        const scoped = this.registry.get(`${this.name}:${type}`);
+        if (scoped) {
+            return scoped;
+        }
+        // Fall back to global lookup
+        return this.registry.get(type);
+    }
+    /**
+     * Scoped state management
+     */
+    useState(key, initialValue) {
+        if (!this.config.enableStateIsolation) {
+            throw new Error('State isolation is disabled for this plugin');
+        }
+        // Initialize state if not present
+        if (!this.state.has(key)) {
+            this.setState(key, initialValue);
+        }
+        const currentValue = this.getState(key) ?? initialValue;
+        const setValue = (value) => {
+            const newValue = typeof value === 'function'
+                ? value(this.getState(key) ?? initialValue)
+                : value;
+            this.setState(key, newValue);
+        };
+        return [currentValue, setValue];
+    }
+    /**
+     * Get scoped state value
+     */
+    getState(key) {
+        return this.state.get(key);
+    }
+    /**
+     * Set scoped state value
+     */
+    setState(key, value) {
+        if (!this.config.enableStateIsolation) {
+            throw new Error('State isolation is disabled for this plugin');
+        }
+        // Check state size limit
+        const stateSize = this.estimateStateSize();
+        const valueSize = this.estimateValueSize(value);
+        if (stateSize + valueSize > this.config.maxStateSize) {
+            throw new Error(`Plugin "${this.name}" exceeded maximum state size of ${this.config.maxStateSize} bytes`);
+        }
+        this.state.set(key, value);
+    }
+    /**
+     * Subscribe to scoped events
+     */
+    on(event, handler) {
+        if (!this.config.enableEventIsolation) {
+            // If isolation is disabled, use global event bus
+            return this.onGlobal(event, handler);
+        }
+        // Scoped event: prefix with plugin name
+        const scopedEvent = `${this.name}:${event}`;
+        return this.eventBus.on(scopedEvent, handler);
+    }
+    /**
+     * Emit a scoped event
+     */
+    emit(event, data) {
+        if (!this.config.enableEventIsolation) {
+            // If isolation is disabled, emit globally
+            this.emitGlobal(event, data);
+            return;
+        }
+        // Scoped event: prefix with plugin name
+        const scopedEvent = `${this.name}:${event}`;
+        this.eventBus.emit(scopedEvent, data);
+    }
+    /**
+     * Emit a global event
+     */
+    emitGlobal(event, data) {
+        if (!this.config.allowGlobalEvents) {
+            throw new Error('Global events are disabled for this plugin');
+        }
+        globalEventBus.emit(event, data);
+    }
+    /**
+     * Subscribe to global events
+     */
+    onGlobal(event, handler) {
+        if (!this.config.allowGlobalEvents) {
+            throw new Error('Global events are disabled for this plugin');
+        }
+        return globalEventBus.on(event, handler);
+    }
+    /**
+     * Clean up all plugin resources
+     */
+    cleanup() {
+        this.state.clear();
+        this.eventBus.cleanup();
+    }
+    /**
+     * Estimate total state size in bytes
+     */
+    estimateStateSize() {
+        let size = 0;
+        for (const value of this.state.values()) {
+            size += this.estimateValueSize(value);
+        }
+        return size;
+    }
+    /**
+     * Estimate size of a value in bytes
+     */
+    estimateValueSize(value) {
+        try {
+            return JSON.stringify(value).length * 2; // UTF-16 encoding
+        }
+        catch {
+            // If not serializable, use rough estimate
+            return 1024; // 1KB default
+        }
+    }
+}

package/dist/registry/PluginSystem.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Registry } from './Registry.js';
+import type { PluginScope, PluginScopeConfig } from '@object-ui/types';
+export interface PluginDefinition {
+    name: string;
+    version: string;
+    dependencies?: string[];
+    peerDependencies?: string[];
+    register: (registry: Registry | PluginScope) => void;
+    onLoad?: () => void | Promise<void>;
+    onUnload?: () => void | Promise<void>;
+    scopeConfig?: PluginScopeConfig;
+}
+export declare class PluginSystem {
+    private plugins;
+    private loaded;
+    private scopes;
+    /**
+     * Load a plugin into the system with optional scope isolation
+     * @param plugin The plugin definition to load
+     * @param registry The component registry to use for registration
+     * @param useScope Whether to use scoped loading (default: true for better isolation)
+     * @throws Error if dependencies are missing
+     */
+    loadPlugin(plugin: PluginDefinition, registry: Registry, useScope?: boolean): Promise<void>;
+    /**
+     * Unload a plugin from the system
+     * @param name The name of the plugin to unload
+     * @throws Error if other plugins depend on this plugin
+     */
+    unloadPlugin(name: string): Promise<void>;
+    /**
+     * Get the scope for a loaded plugin
+     * @param name The name of the plugin
+     * @returns The plugin scope or undefined
+     */
+    getScope(name: string): PluginScope | undefined;
+    /**
+     * Check if a plugin is loaded
+     * @param name The name of the plugin
+     * @returns true if the plugin is loaded
+     */
+    isLoaded(name: string): boolean;
+    /**
+     * Get a loaded plugin definition
+     * @param name The name of the plugin
+     * @returns The plugin definition or undefined
+     */
+    getPlugin(name: string): PluginDefinition | undefined;
+    /**
+     * Get all loaded plugin names
+     * @returns Array of loaded plugin names
+     */
+    getLoadedPlugins(): string[];
+    /**
+     * Get all plugin definitions
+     * @returns Array of all plugin definitions
+     */
+    getAllPlugins(): PluginDefinition[];
+}