@object-ui/core 0.3.0 → 0.5.0

package/src/query/query-ast.ts

@@ -0,0 +1,341 @@
+/**
+ * ObjectUI - Query AST Builder
+ * Phase 3.3: QuerySchema AST implementation
+ * ObjectStack Spec v0.7.1: Window functions support
+ */
+
+import type {
+  QueryAST,
+  QuerySchema,
+  SelectNode,
+  FromNode,
+  WhereNode,
+  JoinNode,
+  GroupByNode,
+  OrderByNode,
+  LimitNode,
+  OffsetNode,
+  AggregateNode,
+  WindowNode,
+  WindowFunction,
+  WindowFrame,
+  WindowConfig,
+  FieldNode,
+  LiteralNode,
+  OperatorNode,
+  LogicalOperator,
+  AdvancedFilterSchema,
+  AdvancedFilterCondition,
+  QuerySortConfig,
+  JoinConfig,
+  AggregationConfig,
+} from '@object-ui/types';
+
+/**
+ * Query AST Builder - Converts QuerySchema to AST
+ */
+export class QueryASTBuilder {
+  build(query: QuerySchema): QueryAST {
+    const ast: QueryAST = {
+      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;
+  }
+
+  private buildSelect(query: QuerySchema): SelectNode {
+    const fields: (FieldNode | AggregateNode | WindowNode)[] = [];
+
+    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,
+    };
+  }
+
+  private buildFrom(query: QuerySchema): FromNode {
+    return {
+      type: 'from',
+      table: query.object,
+    };
+  }
+
+  private buildWhere(filter: AdvancedFilterSchema): WhereNode {
+    return {
+      type: 'where',
+      condition: this.buildFilterCondition(filter),
+    };
+  }
+
+  private buildFilterCondition(filter: AdvancedFilterSchema): OperatorNode {
+    const operator = filter.operator || 'and';
+    const operands: (OperatorNode | FieldNode | LiteralNode)[] = [];
+
+    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 as LogicalOperator,
+      operands,
+    };
+  }
+
+  private buildCondition(condition: AdvancedFilterCondition): OperatorNode {
+    const field = this.buildField(condition.field);
+    
+    // Map filter operators to comparison operators
+    const operatorMap: Record<string, string> = {
+      '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' as any,
+        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 as any,
+        operands: [field, ...condition.values.map(v => this.buildLiteral(v))],
+      };
+    }
+
+    if (operator === 'is_null' || operator === 'is_not_null') {
+      return {
+        type: 'operator',
+        operator: operator as any,
+        operands: [field],
+      };
+    }
+
+    // Standard binary operator
+    const value = this.buildLiteral(condition.value);
+    return {
+      type: 'operator',
+      operator: operator as any,
+      operands: [field, value],
+    };
+  }
+
+  private buildJoin(join: JoinConfig): JoinNode {
+    const onCondition: OperatorNode = {
+      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,
+    };
+  }
+
+  private buildGroupBy(fields: string[]): GroupByNode {
+    return {
+      type: 'group_by',
+      fields: fields.map(field => this.buildField(field)),
+    };
+  }
+
+  private buildOrderBy(sorts: QuerySortConfig[]): OrderByNode {
+    return {
+      type: 'order_by',
+      fields: sorts.map(sort => ({
+        field: this.buildField(sort.field),
+        direction: sort.order,
+      })),
+    };
+  }
+
+  private buildLimit(limit: number): LimitNode {
+    return {
+      type: 'limit',
+      value: limit,
+    };
+  }
+
+  private buildOffset(offset: number): OffsetNode {
+    return {
+      type: 'offset',
+      value: offset,
+    };
+  }
+
+  private buildField(field: string, table?: string): FieldNode {
+    const parts = field.split('.');
+    
+    if (parts.length === 2) {
+      return {
+        type: 'field',
+        table: parts[0],
+        name: parts[1],
+      };
+    }
+
+    return {
+      type: 'field',
+      table,
+      name: field,
+    };
+  }
+
+  private buildLiteral(value: any): LiteralNode {
+    let dataType: 'string' | 'number' | 'boolean' | 'date' | 'null' = '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,
+    };
+  }
+
+  private buildAggregation(agg: AggregationConfig): AggregateNode {
+    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)
+   */
+  private buildWindow(config: WindowConfig): WindowNode {
+    const node: WindowNode = {
+      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: QueryAST): QueryAST {
+    return ast;
+  }
+}
+
+export const defaultQueryASTBuilder = new QueryASTBuilder();
+
+export function buildQueryAST(query: QuerySchema): QueryAST {
+  return defaultQueryASTBuilder.build(query);
+}

package/src/registry/PluginScopeImpl.ts

@@ -0,0 +1,259 @@
+/**
+ * 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, ComponentMeta as RegistryComponentMeta } from './Registry.js';
+
+/**
+ * Event Bus for scoped plugin events
+ */
+class EventBus {
+  private listeners = new Map<string, Set<PluginEventHandler>>();
+
+  on(event: string, handler: PluginEventHandler): () => void {
+    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: string, data?: any): void {
+    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(): void {
+    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 implements PluginScope {
+  public readonly name: string;
+  public readonly version: string;
+  
+  private registry: Registry;
+  private state = new Map<string, any>();
+  private eventBus = new EventBus();
+  private config: Required<PluginScopeConfig>;
+
+  constructor(
+    name: string,
+    version: string,
+    registry: Registry,
+    config?: PluginScopeConfig
+  ) {
+    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: string, component: any, meta?: any): void {
+    // Components are registered as "pluginName:type"
+    const registryMeta: RegistryComponentMeta = {
+      ...meta,
+      namespace: this.name,
+    };
+    this.registry.register(type, component, registryMeta);
+  }
+
+  /**
+   * Get a component from the scoped namespace
+   */
+  getComponent(type: string): any | undefined {
+    // 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<T>(key: string, initialValue: T): [T, (value: T | ((prev: T) => T)) => void] {
+    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<T>(key) ?? initialValue;
+
+    const setValue = (value: T | ((prev: T) => T)) => {
+      const newValue = typeof value === 'function' 
+        ? (value as (prev: T) => T)(this.getState<T>(key) ?? initialValue)
+        : value;
+      this.setState(key, newValue);
+    };
+
+    return [currentValue, setValue];
+  }
+
+  /**
+   * Get scoped state value
+   */
+  getState<T>(key: string): T | undefined {
+    return this.state.get(key);
+  }
+
+  /**
+   * Set scoped state value
+   */
+  setState<T>(key: string, value: T): void {
+    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: string, handler: PluginEventHandler): () => void {
+    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: string, data?: any): void {
+    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: string, data?: any): void {
+    if (!this.config.allowGlobalEvents) {
+      throw new Error('Global events are disabled for this plugin');
+    }
+    globalEventBus.emit(event, data);
+  }
+
+  /**
+   * Subscribe to global events
+   */
+  onGlobal(event: string, handler: PluginEventHandler): () => void {
+    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(): void {
+    this.state.clear();
+    this.eventBus.cleanup();
+  }
+
+  /**
+   * Estimate total state size in bytes
+   */
+  private estimateStateSize(): number {
+    let size = 0;
+    for (const value of this.state.values()) {
+      size += this.estimateValueSize(value);
+    }
+    return size;
+  }
+
+  /**
+   * Estimate size of a value in bytes
+   */
+  private estimateValueSize(value: any): number {
+    try {
+      return JSON.stringify(value).length * 2; // UTF-16 encoding
+    } catch {
+      // If not serializable, use rough estimate
+      return 1024; // 1KB default
+    }
+  }
+}