noormme 1.0.0 → 1.0.2

package/dist/esm/logging/logger.js

@@ -3,19 +3,33 @@
  * Logger for NOORMME
  */
 export class Logger {
-    config;
     queryLogs = [];
     queryCount = 0;
     totalQueryTime = 0;
-    constructor(config = {}) {
-        this.config = config;
+    config;
+    namespace;
+    constructor(configOrNamespace) {
+        if (typeof configOrNamespace === 'string') {
+            this.namespace = configOrNamespace;
+            this.config = { enabled: true, level: 'info' };
+        }
+        else {
+            this.config = configOrNamespace || {};
+        }
+    }
+    /**
+     * Format namespace prefix
+     */
+    getPrefix(level) {
+        const prefix = this.namespace ? `[${this.namespace}]` : '';
+        return `[NOORMME ${level.toUpperCase()}]${prefix}`;
     }
     /**
      * Log debug message
      */
     debug(message, ...args) {
         if (this.shouldLog('debug')) {
-            console.debug(`[NOORMME DEBUG] ${message}`, ...args);
+            console.debug(`${this.getPrefix('debug')} ${message}`, ...args);
         }
     }
     /**
@@ -23,7 +37,7 @@ export class Logger {
      */
     info(message, ...args) {
         if (this.shouldLog('info')) {
-            console.info(`[NOORMME INFO] ${message}`, ...args);
+            console.info(`${this.getPrefix('info')} ${message}`, ...args);
         }
     }
     /**
@@ -31,7 +45,7 @@ export class Logger {
      */
     warn(message, ...args) {
         if (this.shouldLog('warn')) {
-            console.warn(`[NOORMME WARN] ${message}`, ...args);
+            console.warn(`${this.getPrefix('warn')} ${message}`, ...args);
         }
     }
     /**
@@ -39,7 +53,7 @@ export class Logger {
      */
     error(message, ...args) {
         if (this.shouldLog('error')) {
-            console.error(`[NOORMME ERROR] ${message}`, ...args);
+            console.error(`${this.getPrefix('error')} ${message}`, ...args);
         }
     }
     /**

package/dist/esm/noormme.d.ts

@@ -1,7 +1,6 @@
-import type { Kysely } from './kysely.js';
-import { NOORMConfig, SchemaInfo, Repository } from './types/index.js';
+import { Kysely } from './kysely.js';
+import { NOORMConfig, SchemaInfo, Repository, SchemaChange } from './types/index.js';
 import { WatchOptions } from './watch/schema-watcher.js';
-import { QueryAnalyzerOptions } from './performance/query-analyzer.js';
 /**
  * NOORMME - No ORM, just magic!
  * Zero-configuration pseudo-ORM that works with any existing database
@@ -17,12 +16,13 @@ export declare class NOORMME {
     private cacheManager;
     private logger;
     private schemaWatcher;
-    private queryAnalyzer;
+    private metricsCollector;
     private sqliteAutoOptimizer;
     private sqliteAutoIndexer;
     private initialized;
     private repositories;
     private instanceId;
+    private schemaChangeCallbacks;
     constructor(configOrConnectionString?: NOORMConfig | string);
     /**
      * Initialize NOORMME - discovers schema and generates types
@@ -81,7 +81,7 @@ export declare class NOORMME {
     /**
      * Start monitoring schema changes in development mode
      */
-    startSchemaWatching(options?: WatchOptions): void;
+    startSchemaWatching(options?: WatchOptions): Promise<void>;
     /**
      * Stop monitoring schema changes
      */
@@ -89,7 +89,7 @@ export declare class NOORMME {
     /**
      * Register callback for schema changes
      */
-    onSchemaChange(callback: (changes: any[]) => void): void;
+    onSchemaChange(callback: (changes: SchemaChange[]) => void): void;
     /**
      * Get performance metrics
      */
@@ -102,7 +102,7 @@ export declare class NOORMME {
     /**
      * Enable query performance monitoring
      */
-    enablePerformanceMonitoring(options?: QueryAnalyzerOptions): void;
+    enablePerformanceMonitoring(options?: any): void;
     /**
      * Disable query performance monitoring
      */
@@ -111,6 +111,10 @@ export declare class NOORMME {
      * Close database connections
      */
     close(): Promise<void>;
+    /**
+     * Alias for close() - for backward compatibility
+     */
+    destroy(): Promise<void>;
     /**
      * Get the underlying Kysely instance for custom queries
      */
@@ -122,7 +126,7 @@ export declare class NOORMME {
     /**
      * Execute raw SQL
      */
-    execute(sql: string, parameters?: any[]): Promise<any>;
+    execute(sqlString: string, parameters?: unknown[]): Promise<unknown>;
     private mergeConfig;
     /**
      * Parse connection string into NOORMConfig

package/dist/esm/noormme.js

@@ -1,16 +1,20 @@
 /// <reference types="./noormme.d.ts" />
+import { Kysely } from './kysely.js';
 import { SchemaDiscovery } from './schema/schema-discovery.js';
 import { TypeGenerator } from './types/type-generator.js';
 import { RepositoryFactory } from './repository/repository-factory.js';
 import { RelationshipEngine } from './relationships/relationship-engine.js';
 import { CacheManager } from './cache/cache-manager.js';
 import { Logger } from './logging/logger.js';
-import { NoormError } from './errors/NoormError.js';
+import { NoormError, TableNotFoundError } from './errors/NoormError.js';
 import { config as loadDotenv } from 'dotenv';
 import { SchemaWatcher } from './watch/schema-watcher.js';
-import { QueryAnalyzer } from './performance/query-analyzer.js';
+import { MetricsCollector } from './performance/services/metrics-collector.js';
 import { SQLiteAutoOptimizer } from './dialect/sqlite/sqlite-auto-optimizer.js';
 import { SQLiteAutoIndexer } from './dialect/sqlite/sqlite-auto-indexer.js';
+import { SqliteDialect } from './dialect/sqlite/sqlite-dialect.js';
+import Database from 'better-sqlite3';
+import { CompiledQuery } from './query-compiler/compiled-query.js';
 // Global initialization lock to prevent concurrent initialization
 const globalInitLock = new Map();
 /**
@@ -28,12 +32,13 @@ export class NOORMME {
     cacheManager;
     logger;
     schemaWatcher = null;
-    queryAnalyzer = null;
+    metricsCollector = null;
     sqliteAutoOptimizer = null;
     sqliteAutoIndexer = null;
     initialized = false;
     repositories = new Map();
     instanceId;
+    schemaChangeCallbacks = [];
     constructor(configOrConnectionString) {
         // Load .env if it exists
         loadDotenv({ path: '.env' });
@@ -63,7 +68,7 @@ export class NOORMME {
         this.instanceId = `${this.config.dialect}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Initialize Kysely with the provided dialect
         this.dialect = this.createDialect();
-        this.db = new (require('./kysely.js').Kysely)({
+        this.db = new Kysely({
             dialect: this.dialect,
             log: this.config.logging?.enabled ? this.logger.createKyselyLogger() : undefined
         });
@@ -108,34 +113,80 @@ export class NOORMME {
             this.logger.info('Initializing NOORMME...');
             // Test database connection using the dialect-specific introspector
             const introspector = this.dialect.createIntrospector(this.db);
-            await introspector.getTables();
-            this.logger.info('Database connection successful');
-            // Discover schema
+            let tables = [];
+            try {
+                tables = await introspector.getTables();
+                this.logger.info('Database connection successful');
+            }
+            catch (error) {
+                this.logger.warn('Database connection test failed, but continuing with initialization:', error);
+                // Continue with empty schema if connection test fails
+            }
+            // Discover schema - handle empty databases gracefully
             this.logger.info('Discovering database schema...');
-            const schemaInfo = await this.schemaDiscovery.discoverSchema();
-            this.logger.info(`Discovered ${schemaInfo.tables.length} tables`);
-            // Generate types
+            let schemaInfo;
+            try {
+                schemaInfo = await this.schemaDiscovery.discoverSchema();
+                this.logger.info(`Discovered ${schemaInfo.tables.length} tables`);
+            }
+            catch (error) {
+                // In test mode, throw the error instead of silently continuing
+                if (process.env.NODE_ENV === 'test') {
+                    this.logger.error('Schema discovery failed in test mode:', error);
+                    throw new Error(`Schema discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                this.logger.warn('Schema discovery failed, using empty schema:', error);
+                // Create empty schema info if discovery fails
+                schemaInfo = {
+                    tables: [],
+                    relationships: [],
+                    views: []
+                };
+            }
+            // Generate types - handle empty schema gracefully
             this.logger.info('Generating TypeScript types...');
-            const generatedTypes = this.typeGenerator.generateTypes(schemaInfo);
-            this.logger.info(`Generated types for ${generatedTypes.entities.length} entities`);
-            // Cache schema and types
-            await this.cacheManager.set('schema', schemaInfo);
-            await this.cacheManager.set('types', generatedTypes);
-            // Initialize relationship engine
-            this.relationshipEngine.initialize(schemaInfo.relationships);
-            // Initialize query analyzer for development mode
-            this.queryAnalyzer = new QueryAnalyzer(this.db, this.logger, schemaInfo, {
-                enabled: this.config.performance?.enableQueryOptimization ?? true,
+            let generatedTypes;
+            try {
+                generatedTypes = this.typeGenerator.generateTypes(schemaInfo);
+                this.logger.info(`Generated types for ${generatedTypes.entities.length} entities`);
+            }
+            catch (error) {
+                this.logger.warn('Type generation failed, using empty types:', error);
+                // Create empty type info if generation fails
+                generatedTypes = {
+                    entities: [],
+                    relationships: [],
+                    types: {}
+                };
+            }
+            // Cache schema and types - handle caching errors gracefully
+            try {
+                await this.cacheManager.set('schema', schemaInfo);
+                await this.cacheManager.set('types', generatedTypes);
+            }
+            catch (error) {
+                this.logger.warn('Failed to cache schema/types, continuing without cache:', error);
+            }
+            // Initialize relationship engine - handle empty relationships
+            try {
+                this.relationshipEngine.initialize(schemaInfo.relationships);
+            }
+            catch (error) {
+                this.logger.warn('Failed to initialize relationship engine:', error);
+            }
+            // Initialize metrics collector for development mode
+            this.metricsCollector = new MetricsCollector({
+                enabled: process.env.NODE_ENV === 'development',
                 slowQueryThreshold: 1000,
-                missingIndexDetection: true,
-                largeResultSetThreshold: 1000
-            });
+                nPlusOneDetection: true,
+                missingIndexDetection: true
+            }, this.logger);
             // Initialize SQLite-specific auto-optimization features
             if (this.config.dialect === 'sqlite') {
                 this.sqliteAutoOptimizer = SQLiteAutoOptimizer.getInstance(this.logger);
                 this.sqliteAutoIndexer = SQLiteAutoIndexer.getInstance(this.logger);
                 // Apply automatic optimizations if enabled (default: true)
-                const enableAutoOptimization = this.config.performance?.enableAutoOptimization !== false;
+                const enableAutoOptimization = this.config.automation?.enableAutoOptimization !== false;
                 if (enableAutoOptimization) {
                     await this.applySQLiteAutoOptimizations();
                 }
@@ -207,8 +258,8 @@ export class NOORMME {
         if (this.config.dialect === 'sqlite' && this.sqliteAutoIndexer) {
             this.sqliteAutoIndexer.recordQuery(query, executionTime, table);
         }
-        if (this.queryAnalyzer) {
-            this.queryAnalyzer.recordQuery(query, executionTime, undefined, table);
+        if (this.metricsCollector) {
+            this.metricsCollector.recordQuery(query, executionTime, { table });
         }
     }
     /**
@@ -245,7 +296,8 @@ export class NOORMME {
         }
         const table = schemaInfo.tables.find(t => t.name === tableName);
         if (!table) {
-            throw new Error(`Table '${tableName}' not found in schema. Available tables: ${schemaInfo.tables.map(t => t.name).join(', ')}`);
+            const availableTables = schemaInfo.tables.map(t => t.name);
+            throw new TableNotFoundError(tableName, availableTables);
         }
         const repository = this.repositoryFactory.createRepository(table, schemaInfo.relationships);
         this.repositories.set(tableName, repository);
@@ -299,28 +351,34 @@ export class NOORMME {
     /**
      * Start monitoring schema changes in development mode
      */
-    startSchemaWatching(options) {
+    async startSchemaWatching(options) {
         if (!this.initialized) {
             throw new NoormError('NOORMME must be initialized before starting schema watching');
         }
-        if (!this.schemaWatcher) {
-            this.schemaWatcher = new SchemaWatcher(this.db, this.schemaDiscovery, this.logger, options);
-            // Auto-refresh schema when changes detected
-            this.schemaWatcher.onSchemaChange(async (changes) => {
-                this.logger.info(`Schema changes detected: ${changes.length} changes`);
-                changes.forEach(change => {
-                    this.logger.info(`  - ${change.type}: ${change.table}`);
-                });
-                try {
-                    await this.refreshSchema();
-                    this.logger.info('Schema refreshed successfully');
-                }
-                catch (error) {
-                    this.logger.error('Failed to refresh schema:', error);
-                }
-            });
+        // If watcher already exists (e.g., from onSchemaChange), recreate it with new options
+        if (this.schemaWatcher) {
+            this.schemaWatcher.stopWatching();
+        }
+        this.schemaWatcher = new SchemaWatcher(this.db, this.schemaDiscovery, this.logger, options);
+        // Register all previously registered callbacks
+        for (const callback of this.schemaChangeCallbacks) {
+            this.schemaWatcher.onSchemaChange(callback);
         }
-        this.schemaWatcher.startWatching();
+        // Auto-refresh schema when changes detected
+        this.schemaWatcher.onSchemaChange(async (changes) => {
+            this.logger.info(`Schema changes detected: ${changes.length} changes`);
+            changes.forEach(change => {
+                this.logger.info(`  - ${change.type}: ${change.table}`);
+            });
+            try {
+                await this.refreshSchema();
+                this.logger.info('Schema refreshed successfully');
+            }
+            catch (error) {
+                this.logger.error('Failed to refresh schema:', error);
+            }
+        });
+        await this.schemaWatcher.startWatching();
     }
     /**
      * Stop monitoring schema changes
@@ -328,16 +386,19 @@ export class NOORMME {
     stopSchemaWatching() {
         if (this.schemaWatcher) {
             this.schemaWatcher.stopWatching();
+            // Don't set to null - keep watcher instance for potential restart
         }
     }
     /**
      * Register callback for schema changes
      */
     onSchemaChange(callback) {
-        if (!this.schemaWatcher) {
-            this.schemaWatcher = new SchemaWatcher(this.db, this.schemaDiscovery, this.logger);
+        // Store callback so it can be re-registered if watcher is recreated
+        this.schemaChangeCallbacks.push(callback);
+        // If watcher already exists, register callback immediately
+        if (this.schemaWatcher) {
+            this.schemaWatcher.onSchemaChange(callback);
         }
-        this.schemaWatcher.onSchemaChange(callback);
     }
     /**
      * Get performance metrics
@@ -349,10 +410,10 @@ export class NOORMME {
             cacheHitRate: this.cacheManager.getHitRate(),
             repositoryCount: this.repositories.size
         };
-        if (this.queryAnalyzer) {
+        if (this.metricsCollector) {
             return {
                 ...baseMetrics,
-                ...this.queryAnalyzer.getPerformanceStats()
+                ...this.metricsCollector.getPerformanceStats()
             };
         }
         return baseMetrics;
@@ -368,16 +429,21 @@ export class NOORMME {
         if (!schemaInfo) {
             throw new NoormError('Schema not found. Please reinitialize NOORMME.');
         }
-        this.queryAnalyzer = new QueryAnalyzer(this.db, this.logger, schemaInfo, options);
+        this.metricsCollector = new MetricsCollector({
+            enabled: true,
+            slowQueryThreshold: options?.slowQueryThreshold || 1000,
+            nPlusOneDetection: true,
+            missingIndexDetection: true
+        }, this.logger);
         this.logger.info('Query performance monitoring enabled');
     }
     /**
      * Disable query performance monitoring
      */
     disablePerformanceMonitoring() {
-        if (this.queryAnalyzer) {
-            this.queryAnalyzer.clearHistory();
-            this.queryAnalyzer = null;
+        if (this.metricsCollector) {
+            this.metricsCollector.clear();
+            this.metricsCollector = null;
             this.logger.info('Query performance monitoring disabled');
         }
     }
@@ -394,6 +460,12 @@ export class NOORMME {
         this.repositories.clear();
         this.logger.info('NOORMME closed');
     }
+    /**
+     * Alias for close() - for backward compatibility
+     */
+    async destroy() {
+        return this.close();
+    }
     /**
      * Get the underlying Kysely instance for custom queries
      */
@@ -409,11 +481,9 @@ export class NOORMME {
     /**
      * Execute raw SQL
      */
-    async execute(sql, parameters) {
-        return await this.db.executeQuery({
-            sql,
-            parameters: parameters || []
-        });
+    async execute(sqlString, parameters) {
+        const compiledQuery = CompiledQuery.raw(sqlString, parameters || []);
+        return await this.db.executeQuery(compiledQuery);
     }
     mergeConfig(config) {
         return {
@@ -505,8 +575,7 @@ export class NOORMME {
         const { dialect, connection } = this.config;
         switch (dialect) {
             case 'sqlite':
-                const Database = require('better-sqlite3');
-                return new (require('./dialect/sqlite/sqlite-dialect').SqliteDialect)({
+                return new SqliteDialect({
                     database: new Database(connection.database)
                 });
             default:

package/dist/esm/operation-node/column-node.js

@@ -1,6 +1,7 @@
 /// <reference types="./column-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { IdentifierNode } from './identifier-node.js';
+import { validateIdentifier } from '../util/security-validator.js';
 /**
  * @internal
  */
@@ -9,6 +10,9 @@ export const ColumnNode = freeze({
         return node.kind === 'ColumnNode';
     },
     create(column) {
+        // SECURITY: Validate column name to prevent SQL injection
+        // Even though IdentifierNode will validate, we validate here too for defense in depth
+        validateIdentifier(column, 'column name');
         return freeze({
             kind: 'ColumnNode',
             column: IdentifierNode.create(column),

package/dist/esm/operation-node/identifier-node.js

@@ -1,5 +1,6 @@
 /// <reference types="./identifier-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { validateIdentifier } from '../util/security-validator.js';
 /**
  * @internal
  */
@@ -8,6 +9,9 @@ export const IdentifierNode = freeze({
         return node.kind === 'IdentifierNode';
     },
     create(name) {
+        // SECURITY: Validate identifier to prevent SQL injection at the lowest level
+        // This ensures ALL identifiers are validated, even when parsers are called directly
+        validateIdentifier(name, 'identifier');
         return freeze({
             kind: 'IdentifierNode',
             name,

package/dist/esm/operation-node/table-node.js

@@ -1,6 +1,7 @@
 /// <reference types="./table-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import { validateIdentifier } from '../util/security-validator.js';
 /**
  * @internal
  */
@@ -9,12 +10,18 @@ export const TableNode = freeze({
         return node.kind === 'TableNode';
     },
     create(table) {
+        // SECURITY: Validate table name to prevent SQL injection
+        // Even though SchemableIdentifierNode will validate, we validate here too for defense in depth
+        validateIdentifier(table, 'table name');
         return freeze({
             kind: 'TableNode',
             table: SchemableIdentifierNode.create(table),
         });
     },
     createWithSchema(schema, table) {
+        // SECURITY: Validate both schema and table names
+        validateIdentifier(schema, 'schema name');
+        validateIdentifier(table, 'table name');
         return freeze({
             kind: 'TableNode',
             table: SchemableIdentifierNode.createWithSchema(schema, table),

package/dist/esm/parser/reference-parser.js

@@ -45,13 +45,16 @@ export function parseJSONReference(ref, op) {
 export function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';
     if (!ref.includes(COLUMN_SEPARATOR)) {
+        // SECURITY: ColumnNode.create will validate the column name
         return ReferenceNode.create(ColumnNode.create(ref));
     }
     const parts = ref.split(COLUMN_SEPARATOR).map(trim);
     if (parts.length === 3) {
+        // SECURITY: parseStringReferenceWithTableAndSchema uses ColumnNode and TableNode which validate
         return parseStringReferenceWithTableAndSchema(parts);
     }
     if (parts.length === 2) {
+        // SECURITY: parseStringReferenceWithTable uses ColumnNode and TableNode which validate
         return parseStringReferenceWithTable(parts);
     }
     throw new Error(`invalid column reference ${ref}`);
@@ -84,10 +87,12 @@ export function parseOrderedColumnName(column) {
 }
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
+    // SECURITY: Both ColumnNode.create and TableNode.createWithSchema validate their inputs
     return ReferenceNode.create(ColumnNode.create(column), TableNode.createWithSchema(schema, table));
 }
 function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
+    // SECURITY: Both ColumnNode.create and TableNode.create validate their inputs
     return ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
 }
 function trim(str) {

package/dist/esm/parser/table-parser.js

@@ -38,9 +38,11 @@ export function parseTable(from) {
     const SCHEMA_SEPARATOR = '.';
     if (from.includes(SCHEMA_SEPARATOR)) {
         const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
+        // SECURITY: TableNode.createWithSchema will validate both parts
         return TableNode.createWithSchema(schema, table);
     }
     else {
+        // SECURITY: TableNode.create will validate the table name
         return TableNode.create(from);
     }
 }

package/dist/esm/performance/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Performance module exports
+ * Clean, focused services, utilities, and classes
+ */
+export * from './utils/query-parser';
+export * from './services/cache-service';
+export * from './services/metrics-collector';
+export * from './services/connection-factory';
+export * from './query-optimizer';
+/**
+ * Default performance configuration
+ */
+export declare const defaultPerformanceConfig: {
+    cache: {
+        maxSize: number;
+        defaultTtl: number;
+        cleanupInterval: number;
+        enableMetrics: boolean;
+    };
+    metrics: {
+        enabled: boolean;
+        slowQueryThreshold: number;
+        nPlusOneDetection: boolean;
+        missingIndexDetection: boolean;
+        largeResultSetThreshold: number;
+        maxHistorySize: number;
+        warningRetentionDays: number;
+    };
+    connectionPool: {
+        minConnections: number;
+        maxConnections: number;
+        acquireTimeout: number;
+        idleTimeout: number;
+        validationInterval: number;
+    };
+    optimizer: {
+        enableQueryCache: boolean;
+        enableIndexRecommendations: boolean;
+        enableQueryRewriting: boolean;
+        slowQueryThreshold: number;
+        cacheSize: number;
+        maxCacheAge: number;
+    };
+};

package/dist/esm/performance/index.js

@@ -0,0 +1,48 @@
+/// <reference types="./index.d.ts" />
+/**
+ * Performance module exports
+ * Clean, focused services, utilities, and classes
+ */
+// Utilities
+export * from './utils/query-parser';
+// Services
+export * from './services/cache-service';
+export * from './services/metrics-collector';
+export * from './services/connection-factory';
+// Main optimizer
+export * from './query-optimizer';
+/**
+ * Default performance configuration
+ */
+export const defaultPerformanceConfig = {
+    cache: {
+        maxSize: 1000,
+        defaultTtl: 300000, // 5 minutes
+        cleanupInterval: 60000, // 1 minute
+        enableMetrics: true
+    },
+    metrics: {
+        enabled: true,
+        slowQueryThreshold: 1000,
+        nPlusOneDetection: true,
+        missingIndexDetection: true,
+        largeResultSetThreshold: 1000,
+        maxHistorySize: 10000,
+        warningRetentionDays: 7
+    },
+    connectionPool: {
+        minConnections: 2,
+        maxConnections: 10,
+        acquireTimeout: 30000,
+        idleTimeout: 300000,
+        validationInterval: 60000
+    },
+    optimizer: {
+        enableQueryCache: true,
+        enableIndexRecommendations: true,
+        enableQueryRewriting: true,
+        slowQueryThreshold: 1000,
+        cacheSize: 1000,
+        maxCacheAge: 300000
+    }
+};