@object-ui/core 3.3.0 → 3.3.1

package/src/query/query-ast.ts

@@ -1,341 +0,0 @@
-/**
- * ObjectUI - Query AST Builder
- * Phase 3.3: QuerySchema AST implementation
- * ObjectStack Spec v2.0.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 v2.0.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 v2.0.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

@@ -1,259 +0,0 @@
-/**
- * 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
-    }
-  }
-}