elit 3.3.3 → 3.3.5

package/src/database.ts

@@ -335,20 +335,16 @@ class VM {
     }
 }
 
-function create(dbName: string, code: string | Function): void {
-    const DIR = "databases";
-    const basePath = path.join(process.cwd());
-    const baseDir: string = path.resolve(basePath, DIR); // โฟลเดอร์ที่อนุญาต   
-    const dbPath = path.join(baseDir, `${dbName}.ts`);
+function create(dbName: string, code: string | Function, options?: VMOptions): void {
+    const DIR = options?.dir || path.join(process.cwd(), 'databases');
+    const dbPath = path.join(DIR, `${dbName}.ts`);
     // Prepare the export line
     fs.appendFileSync(dbPath, code.toString(), 'utf8');
 }
 
-function read(dbName: string): string {
-    const DIR = "databases";
-    const basePath = path.join(process.cwd());
-    const baseDir: string = path.resolve(basePath, DIR);
-    const dbPath = path.join(baseDir, `${dbName}.ts`);
+function read(dbName: string, options?: VMOptions): string {
+    const DIR = options?.dir || path.join(process.cwd(), 'databases');
+    const dbPath = path.join(DIR, `${dbName}.ts`);
 
     if (!fs.existsSync(dbPath)) {
         throw new Error(`Database '${dbName}' not found`);
@@ -357,11 +353,9 @@ function read(dbName: string): string {
     return fs.readFileSync(dbPath, 'utf8');
 }
 
-function remove(dbName: string, fnName: string) {
-    const DIR = "databases";
-    const basePath = path.join(process.cwd());
-    const baseDir: string = path.resolve(basePath, DIR); // โฟลเดอร์ที่อนุญาต   
-    const dbPath = path.join(baseDir, `${dbName}.ts`);
+function remove(dbName: string, fnName: string, options?: VMOptions) {
+    const DIR = options?.dir || path.join(process.cwd(), 'databases');
+    const dbPath = path.join(DIR, `${dbName}.ts`);
     if (!fs.existsSync(dbPath)) return false;
 
     // if no functionName provided -> remove the whole file (after backup)
@@ -454,12 +448,10 @@ function remove(dbName: string, fnName: string) {
     return `Removed ${fnName} from database ${dbName}.`;
 }
 
-function rename(oldName: string, newName: string): string {
-    const DIR = "databases";
-    const basePath = path.join(process.cwd());
-    const baseDir: string = path.resolve(basePath, DIR); // โฟลเดอร์ที่อนุญาต   
-    const oldPath = path.join(baseDir, `${oldName}.ts`);
-    const newPath = path.join(baseDir, `${newName}.ts`);
+function rename(oldName: string, newName: string, options?: VMOptions): string {
+    const DIR = options?.dir || path.join(process.cwd(), 'databases');
+    const oldPath = path.join(DIR, `${oldName}.ts`);
+    const newPath = path.join(DIR, `${newName}.ts`);
 
     // Check if the source file exists
     if (!fs.existsSync(oldPath)) {
@@ -480,22 +472,18 @@ function rename(oldName: string, newName: string): string {
     }
 }
 
-function save(dbName: string, code: string | Function | any): void {
-    const DIR = "databases";
-    const basePath = path.join(process.cwd());
-    const baseDir: string = path.resolve(basePath, DIR); // โฟลเดอร์ที่อนุญาต   
-    const dbPath = path.join(baseDir, `${dbName}.ts`);
+function save(dbName: string, code: string | Function | any, options?: VMOptions): void {
+    const DIR = options?.dir || path.join(process.cwd(), 'databases');
+    const dbPath = path.join(DIR, `${dbName}.ts`);
 
     let fileContent = typeof code === 'function' ? code.toString() : code;
 
     fs.writeFileSync(dbPath, fileContent, 'utf8');
 }
 
-function update(dbName: string, fnName: string, code: string | Function) {
-    const DIR = "databases";
-    const basePath = path.join(process.cwd());
-    const baseDir: string = path.resolve(basePath, DIR); // โฟลเดอร์ที่อนุญาต
-    const dbPath = path.join(baseDir, `${dbName}.ts`);
+function update(dbName: string, fnName: string, code: string | Function, options?: VMOptions) {
+    const DIR = options?.dir || path.join(process.cwd(), 'databases');
+    const dbPath = path.join(DIR, `${dbName}.ts`);
 
     let src;
 
@@ -710,11 +698,15 @@ async function SystemModuleResolver() {
 
 export class Database {
     private vm: VM;
+    private options: VMOptions;
+
     constructor(options?: VMOptions) {
-        this.vm = new VM({
-            language: 'ts', registerModules: {},
+        this.options = {
+            language: 'ts',
+            registerModules: {},
             ...options
-        });
+        };
+        this.vm = new VM(this.options);
     }
 
     register(context: { [key: string]: any }) {
@@ -724,9 +716,53 @@ export class Database {
     async execute(code: string) {
         return await this.vm.run(code);
     }
+
+    // ===== Database Helper Methods =====
+
+    /**
+     * Create a new database file with the given code
+     */
+    create(dbName: string, code: string | Function): void {
+        return create(dbName, code, this.options);
+    }
+
+    /**
+     * Read the contents of a database file
+     */
+    read(dbName: string): string {
+        return read(dbName, this.options);
+    }
+
+    /**
+     * Remove a function or the entire database file
+     */
+    remove(dbName: string, fnName?: string): string | boolean {
+       return remove(dbName, fnName || "", this.options);
+    }
+
+    /**
+     * Rename a database file
+     */
+    rename(oldName: string, newName: string): string {
+       return rename(oldName, newName, this.options);
+    }
+
+    /**
+     * Save code to a database file (overwrites existing content)
+     */
+    save(dbName: string, code: string | Function | any): void {
+       return save(dbName, code, this.options);
+    }
+
+    /**
+     * Update a function in a database file
+     */
+    update(dbName: string, fnName: string, code: string | Function): string {
+       return update(dbName, fnName, code, this.options);
+    }
 }
 
-// Export helper functions
+// Export Database class and keep helper functions for backward compatibility
 export { create, read, remove, rename, save, update };
 
 

package/src/server.ts

@@ -174,6 +174,18 @@ export class ServerRouter {
     return query;
   }
 
+  /**
+   * List all registered routes for debugging
+   */
+  listRoutes(): Array<{ method: string; pattern: string; paramNames: string[]; handler: string }> {
+    return this.routes.map(route => ({
+      method: route.method,
+      pattern: route.pattern.source,
+      paramNames: route.paramNames,
+      handler: route.handler.name || '(anonymous)'
+    }));
+  }
+
   private async parseBody(req: IncomingMessage): Promise<any> {
     // Bun compatibility: Check if req has text() method (Bun Request)
     if (typeof (req as any).text === 'function') {
@@ -1757,7 +1769,19 @@ export default css;
   watcher.on('change', (path: string) => {
     if (config.logging) console.log(`[HMR] File changed: ${path}`);
     const message = JSON.stringify({ type: 'update', path, timestamp: Date.now() } as HMRMessage);
-    wsClients.forEach(client => client.readyState === ReadyState.OPEN && client.send(message));
+    // Broadcast to all open clients with error handling
+    wsClients.forEach(client => {
+      if (client.readyState === ReadyState.OPEN) {
+        client.send(message, {}, (err?: Error) => {
+          // Silently ignore connection errors during HMR
+          const code = (err as any)?.code;
+          if (code === 'ECONNABORTED' || code === 'ECONNRESET' || code === 'EPIPE' || code === 'WS_NOT_OPEN') {
+            // Client disconnected - will be removed from clients set by close event
+            return;
+          }
+        });
+      }
+    });
   });
 
   watcher.on('add', (path: string) => config.logging && console.log(`[HMR] File added: ${path}`));

package/src/test-globals.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Test Global Type Definitions
+ *
+ * Provides global type declarations for test globals.
+ *
+ * To use these types in your test files, add this to your tsconfig.json:
+ * {
+ *   "compilerOptions": {
+ *     "types": ["elit/test-globals"]
+ *   }
+ * }
+ *
+ * Or add a triple-slash directive to your test file:
+ * /// <reference types="elit/test-globals" />
+ */
+
+// ============================================================================
+// Global Functions with Modifiers
+// ============================================================================
+
+declare function describe(name: string, fn: () => void): void;
+declare namespace describe {
+    function skip(name: string, fn: () => void): void;
+    function only(name: string, fn: () => void): void;
+}
+
+declare function it(name: string, fn: () => void | Promise<void>): void;
+declare namespace it {
+    function skip(name: string, fn: () => void | Promise<void>): void;
+    function only(name: string, fn: () => void | Promise<void>): void;
+    function todo(name: string, fn?: () => void | Promise<void>): void;
+}
+
+declare function test(name: string, fn: () => void | Promise<void>): void;
+declare namespace test {
+    function skip(name: string, fn: () => void | Promise<void>): void;
+    function only(name: string, fn: () => void | Promise<void>): void;
+    function todo(name: string, fn?: () => void | Promise<void>): void;
+}
+
+// ============================================================================
+// Expect Interface
+// ============================================================================
+
+interface TestMatchers<T> {
+    // Equality
+    toBe(value: T): void;
+    toEqual(value: T): void;
+    toStrictEqual(value: T): void;
+
+    // Truthiness
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+
+    // Nullability
+    toBeNull(): void;
+    toBeUndefined(): void;
+    toBeDefined(): void;
+    toBeNaN(): void;
+
+    // Numbers
+    toBeGreaterThan(value: number): void;
+    toBeGreaterThanOrEqual(value: number): void;
+    toBeLessThan(value: number): void;
+    toBeLessThanOrEqual(value: number): void;
+    toBeCloseTo(value: number, precision?: number): void;
+    toBeFinite(): void;
+
+    // Strings
+    toMatch(pattern: RegExp | string): void;
+    toContain(value: any): void;
+
+    // Arrays
+    toHaveLength(length: number): void;
+    toContainEqual(item: any): void;
+
+    // Objects
+    toHaveProperty(path: string | (string | number)[], value?: any): void;
+    toMatchObject(properties: Record<string, any>): void;
+    toBeInstanceOf(classType: any): void;
+
+    // Functions
+    toThrow(error?: RegExp | string | Error | any): void;
+    toHaveReturnedWith(value: any): void;
+    toHaveReturnedTimes(times: number): void;
+    toHaveLastReturnedWith(value: any): void;
+
+    // Modifiers
+    not: TestMatchers<T>;
+    resolves: TestMatchers<T>;
+    rejects: TestMatchers<T>;
+}
+
+interface ExpectStatic {
+    <T = any>(actual: T): TestMatchers<T>;
+    extends(matchers: Record<string, any>): void;
+    any(constructor: any): any;
+    anything(): any;
+    arrayContaining(arr: any[]): any;
+    objectContaining(obj: Record<string, any>): any;
+    stringContaining(str: string): any;
+    stringMatching(str: RegExp | string): any;
+    not: {
+        toBe(value: any): void;
+        toEqual(value: any): void;
+        toMatchObject(properties: Record<string, any>): void;
+        toContain(value: any): void;
+        toThrow(error?: RegExp | string | Error): void;
+    };
+    addSnapshotSerializer(serializer: any): void;
+    assertions(expected: number): void;
+    hasAssertions(): void;
+}
+
+declare const expect: ExpectStatic;
+
+// ============================================================================
+// Mock Functions (vi)
+// ============================================================================
+
+interface MockFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): ReturnType<T>;
+    mockImplementation(fn: T): this;
+    mockImplementationOnce(fn: T): this;
+    mockReturnThis(): this;
+    mockReturnValue(value: ReturnType<T>): this;
+    mockReturnValueOnce(value: ReturnType<T>): this;
+    mockResolvedValue(value: ReturnType<T> extends Promise<any> ? never : Awaited<ReturnType<T>>): this;
+    mockResolvedValueOnce(value: ReturnType<T> extends Promise<any> ? never : Awaited<ReturnType<T>>): this;
+    mockRejectedValue(value: any): this;
+    mockRejectedValueOnce(value: any): this;
+    get mock(): {
+        calls: Parameters<T>[];
+        instances: any[];
+        contexts: any[];
+        returnValues: ReturnType<T>[];
+        lastCall?: Parameters<T>;
+    };
+    get calls(): Parameters<T>[];
+    get instances(): any[];
+    get invocationCallOrder(): number[];
+    get results(): Array<{ type: 'return' | 'throw' | 'incomplete'; value: any }>;
+}
+
+interface SpyInstance {
+    mockRestore(): void;
+    mockReturnValue(value: any): this;
+    mockResolvedValue(value: any): this;
+    mockRejectedValue(value: any): this;
+    mockImplementation(fn: (...args: any[]) => any): this;
+    get calls(): any[][];
+    get callCount(): number;
+}
+
+interface Elitest {
+    fn<T extends (...args: any[]) => any>(implementation?: T): MockFunction<T>;
+    spyOn(object: any, method: string): SpyInstance;
+    clearAllMocks(): void;
+    resetAllMocks(): void;
+    restoreAllMocks(): void;
+    doMock(modulePath: string, mockFactory?: () => any): void;
+    dontMock(modulePath: string): void;
+    unmock(modulePath: string): void;
+    useFakeTimers(): void;
+    useRealTimers(): void;
+    runAllTimers(): void;
+    runOnlyPendingTimers(): void;
+    advanceTimersByTime(msToRun: number): void;
+    advanceTimersToNextTimer(): number;
+    clearAllTimers(): void;
+    setSystemTime(time?: number | Date): void;
+    getTimerCount(): number;
+}
+
+declare const vi: Elitest;
+
+// ============================================================================
+// Hooks
+// ============================================================================
+
+declare function beforeAll(fn: () => void | Promise<void>, timeout?: number): void;
+declare function afterAll(fn: () => void | Promise<void>, timeout?: number): void;
+declare function beforeEach(fn: () => void | Promise<void>, timeout?: number): void;
+declare function afterEach(fn: () => void | Promise<void>, timeout?: number): void;