wynkjs 1.0.2 → 1.0.4

package/dist/schema-registry.js

@@ -0,0 +1,134 @@
+/**
+ * Schema Registry for storing and retrieving custom error messages
+ * This allows validation pipes to look up custom error messages from schemas
+ */
+class SchemaRegistry {
+    static instance;
+    errorMessages = {};
+    routeSchemas = {};
+    constructor() { }
+    static getInstance() {
+        if (!SchemaRegistry.instance) {
+            SchemaRegistry.instance = new SchemaRegistry();
+        }
+        return SchemaRegistry.instance;
+    }
+    /**
+     * Register custom error messages for a schema
+     * @param schemaKey Unique key for the schema (e.g., class name + method)
+     * @param schema The TypeBox schema object
+     */
+    registerSchema(schemaKey, schema) {
+        if (!schema || typeof schema !== "object")
+            return;
+        const messages = {};
+        this.extractErrorMessages(schema, "", messages);
+        if (Object.keys(messages).length > 0) {
+            this.errorMessages[schemaKey] = messages;
+        }
+    }
+    /**
+     * Register route-to-schema mapping
+     * @param method HTTP method (GET, POST, etc.)
+     * @param path Route path
+     * @param schemaKey The schema key
+     * @param validationType Type of validation (body, query, params)
+     */
+    registerRoute(method, path, schemaKey, validationType) {
+        const routeKey = `${method.toUpperCase()}:${path}`;
+        if (!this.routeSchemas[routeKey]) {
+            this.routeSchemas[routeKey] = [];
+        }
+        this.routeSchemas[routeKey].push({ schemaKey, validationType });
+    }
+    /**
+     * Get schema key for a route and validation type
+     * @param method HTTP method
+     * @param path Route path (actual request path with values)
+     * @param validationType Type of validation
+     * @returns Schema key or undefined
+     */
+    getSchemaKeyForRoute(method, path, validationType) {
+        // First try exact match
+        const exactKey = `${method.toUpperCase()}:${path}`;
+        if (this.routeSchemas[exactKey]) {
+            const found = this.routeSchemas[exactKey].find((s) => s.validationType === validationType);
+            if (found)
+                return found.schemaKey;
+        }
+        // If no exact match, try to match patterns
+        // e.g., request path "/users/10/100" should match pattern "/users/:id1/:id2"
+        for (const [routeKey, schemas] of Object.entries(this.routeSchemas)) {
+            // Split only on the first colon to separate method from path
+            const colonIndex = routeKey.indexOf(":");
+            const routeMethod = routeKey.substring(0, colonIndex);
+            const routePath = routeKey.substring(colonIndex + 1);
+            if (routeMethod !== method.toUpperCase())
+                continue;
+            // Check if the routePath is a pattern (contains :param)
+            if (routePath.includes(":")) {
+                // Convert pattern to regex
+                const pattern = routePath
+                    .replace(/:[^/]+/g, "([^/]+)") // Replace :param with regex group
+                    .replace(/\//g, "\\/"); // Escape slashes
+                const regex = new RegExp(`^${pattern}$`);
+                if (regex.test(path)) {
+                    const found = schemas.find((s) => s.validationType === validationType);
+                    if (found)
+                        return found.schemaKey;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Recursively extract error messages from schema
+     */
+    extractErrorMessages(schema, path, messages) {
+        // Check for custom error message at current level
+        if (schema.error || schema.errorMessage) {
+            messages[path || "root"] = schema.error || schema.errorMessage;
+        }
+        // Recurse into object properties
+        if (schema.type === "object" && schema.properties) {
+            for (const [key, value] of Object.entries(schema.properties)) {
+                const newPath = path ? `${path}.${key}` : key;
+                this.extractErrorMessages(value, newPath, messages);
+            }
+        }
+        // Recurse into array items
+        if (schema.type === "array" && schema.items) {
+            const newPath = path ? `${path}[]` : "[]";
+            this.extractErrorMessages(schema.items, newPath, messages);
+        }
+    }
+    /**
+     * Get custom error message for a field path
+     * @param schemaKey The schema key
+     * @param fieldPath The field path (e.g., "user.email")
+     * @returns Custom error message or undefined
+     */
+    getErrorMessage(schemaKey, fieldPath) {
+        const schemaMessages = this.errorMessages[schemaKey];
+        if (!schemaMessages)
+            return undefined;
+        // Try exact match first
+        if (schemaMessages[fieldPath]) {
+            return schemaMessages[fieldPath];
+        }
+        // Try without array indices (e.g., "items.0.name" -> "items[].name")
+        const normalizedPath = fieldPath.replace(/\.\d+\./g, "[].");
+        if (schemaMessages[normalizedPath]) {
+            return schemaMessages[normalizedPath];
+        }
+        return undefined;
+    }
+    /**
+     * Clear all registered schemas (useful for testing)
+     */
+    clear() {
+        this.errorMessages = {};
+        this.routeSchemas = {};
+    }
+}
+export const schemaRegistry = SchemaRegistry.getInstance();

package/dist/testing/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * WynkJS Testing Module
+ * Built-in testing utilities for WynkJS applications
+ * Works with Bun's native test runner
+ */
+/**
+ * Test class for creating isolated testing modules
+ */
+export declare class Test {
+    /**
+     * Create a testing module with providers
+     * @param options Testing module options
+     * @returns TestingModule instance
+     */
+    static createTestingModule(options: TestingModuleOptions): TestingModule;
+}
+/**
+ * Options for creating a testing module
+ */
+export interface TestingModuleOptions {
+    /**
+     * Array of providers (services, classes) to register in the testing container
+     */
+    providers?: any[];
+    /**
+     * Array of controllers to register in the testing container
+     */
+    controllers?: any[];
+}
+/**
+ * Testing module that provides isolated dependency injection container
+ */
+export declare class TestingModule {
+    private testContainer;
+    private providers;
+    private controllers;
+    constructor(options: TestingModuleOptions);
+    /**
+     * Compile the testing module (register all providers and controllers)
+     */
+    compile(): Promise<TestingModule>;
+    /**
+     * Get an instance of a provider from the testing container
+     * @param type The class/token to resolve
+     * @returns Instance of the requested type
+     */
+    get<T>(type: any): T;
+    /**
+     * Close the testing module and clean up
+     */
+    close(): Promise<void>;
+}
+/**
+ * Mock factory for creating mock instances
+ */
+export declare class MockFactory {
+    /**
+     * Create a mock object with methods
+     * @param methods Object with method names and return values
+     * @returns Mock object
+     */
+    static createMock<T = any>(methods?: Record<string, any>): T;
+    /**
+     * Create a spy function that tracks calls
+     * @param implementation Optional implementation
+     * @returns Spy function
+     */
+    static createSpy(implementation?: (...args: any[]) => any): any;
+}
+/**
+ * Export everything for convenient imports
+ */
+export * from "./test-utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../core/testing/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;GAEG;AACH,qBAAa,IAAI;IACf;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa;CAGzE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC;IAElB;;OAEG;IACH,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,WAAW,CAAQ;gBAEf,OAAO,EAAE,oBAAoB;IAOzC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;IAcvC;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC;IAIpB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,CAAC;IAchE;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,GAAG;CAiBhE;AAED;;GAEG;AACH,cAAc,cAAc,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,106 @@
+/**
+ * WynkJS Testing Module
+ * Built-in testing utilities for WynkJS applications
+ * Works with Bun's native test runner
+ */
+import { container } from "tsyringe";
+/**
+ * Test class for creating isolated testing modules
+ */
+export class Test {
+    /**
+     * Create a testing module with providers
+     * @param options Testing module options
+     * @returns TestingModule instance
+     */
+    static createTestingModule(options) {
+        return new TestingModule(options);
+    }
+}
+/**
+ * Testing module that provides isolated dependency injection container
+ */
+export class TestingModule {
+    testContainer;
+    providers;
+    controllers;
+    constructor(options) {
+        // Create a child container for isolation
+        this.testContainer = container.createChildContainer();
+        this.providers = options.providers || [];
+        this.controllers = options.controllers || [];
+    }
+    /**
+     * Compile the testing module (register all providers and controllers)
+     */
+    async compile() {
+        // Register all providers
+        for (const provider of this.providers) {
+            this.testContainer.register(provider, { useClass: provider });
+        }
+        // Register all controllers
+        for (const controller of this.controllers) {
+            this.testContainer.register(controller, { useClass: controller });
+        }
+        return this;
+    }
+    /**
+     * Get an instance of a provider from the testing container
+     * @param type The class/token to resolve
+     * @returns Instance of the requested type
+     */
+    get(type) {
+        return this.testContainer.resolve(type);
+    }
+    /**
+     * Close the testing module and clean up
+     */
+    async close() {
+        // Reset the test container
+        this.testContainer.reset();
+    }
+}
+/**
+ * Mock factory for creating mock instances
+ */
+export class MockFactory {
+    /**
+     * Create a mock object with methods
+     * @param methods Object with method names and return values
+     * @returns Mock object
+     */
+    static createMock(methods = {}) {
+        const mock = {};
+        for (const [key, value] of Object.entries(methods)) {
+            if (typeof value === "function") {
+                mock[key] = value;
+            }
+            else {
+                mock[key] = () => value;
+            }
+        }
+        return mock;
+    }
+    /**
+     * Create a spy function that tracks calls
+     * @param implementation Optional implementation
+     * @returns Spy function
+     */
+    static createSpy(implementation) {
+        const calls = [];
+        const spy = (...args) => {
+            calls.push(args);
+            return implementation ? implementation(...args) : undefined;
+        };
+        spy.calls = calls;
+        spy.mock = {
+            calls,
+            results: calls.map((args) => implementation ? implementation(...args) : undefined),
+        };
+        return spy;
+    }
+}
+/**
+ * Export everything for convenient imports
+ */
+export * from "./test-utils";

package/dist/testing/test-utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Testing utilities and helpers
+ */
+/**
+ * Create a mock request object for testing controllers
+ */
+export declare function createMockRequest(options?: {
+    method?: string;
+    url?: string;
+    body?: any;
+    params?: Record<string, string>;
+    query?: Record<string, any>;
+    headers?: Record<string, string>;
+}): any;
+/**
+ * Create a mock response object for testing controllers
+ */
+export declare function createMockResponse(): any;
+/**
+ * Create a mock execution context for testing guards, interceptors, etc.
+ */
+export declare function createMockExecutionContext(request?: any, response?: any): any;
+/**
+ * Assert that a value is defined (not null or undefined)
+ */
+export declare function assertDefined<T>(value: T | null | undefined): asserts value is T;
+/**
+ * Assert that a value is an instance of a class
+ */
+export declare function assertInstanceOf<T>(value: any, type: new (...args: any[]) => T): asserts value is T;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/testing/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../core/testing/test-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B,GACL,GAAG,CASL;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CAwBxC;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,GAAyB,EAClC,QAAQ,GAAE,GAA0B,GACnC,GAAG,CASL;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAC1B,OAAO,CAAC,KAAK,IAAI,CAAC,CAIpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAC9B,OAAO,CAAC,KAAK,IAAI,CAAC,CAIpB"}

package/dist/testing/test-utils.js

@@ -0,0 +1,72 @@
+/**
+ * Testing utilities and helpers
+ */
+/**
+ * Create a mock request object for testing controllers
+ */
+export function createMockRequest(options = {}) {
+    return {
+        method: options.method || "GET",
+        url: options.url || "/",
+        body: options.body || {},
+        params: options.params || {},
+        query: options.query || {},
+        headers: options.headers || {},
+    };
+}
+/**
+ * Create a mock response object for testing controllers
+ */
+export function createMockResponse() {
+    const response = {
+        statusCode: 200,
+        headers: {},
+        body: null,
+        status: function (code) {
+            this.statusCode = code;
+            return this;
+        },
+        send: function (data) {
+            this.body = data;
+            return this;
+        },
+        json: function (data) {
+            this.body = data;
+            return this;
+        },
+        setHeader: function (name, value) {
+            this.headers[name] = value;
+            return this;
+        },
+    };
+    return response;
+}
+/**
+ * Create a mock execution context for testing guards, interceptors, etc.
+ */
+export function createMockExecutionContext(request = createMockRequest(), response = createMockResponse()) {
+    return {
+        getRequest: () => request,
+        getResponse: () => response,
+        switchToHttp: () => ({
+            getRequest: () => request,
+            getResponse: () => response,
+        }),
+    };
+}
+/**
+ * Assert that a value is defined (not null or undefined)
+ */
+export function assertDefined(value) {
+    if (value === null || value === undefined) {
+        throw new Error("Expected value to be defined");
+    }
+}
+/**
+ * Assert that a value is an instance of a class
+ */
+export function assertInstanceOf(value, type) {
+    if (!(value instanceof type)) {
+        throw new Error(`Expected value to be instance of ${type.name}`);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wynkjs",
-  "version": "1.0.2",
-  "description": "A high-performance TypeScript framework built on Elysia for Bun with NestJS-style decorators - 20x faster than Express",
+  "version": "1.0.4",
+  "description": "A high-performance TypeScript framework built on Elysia for Bun with elegant decorator-based architecture - 10x faster than Express/NestJS",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,6 +10,10 @@
     "wynk",
     "wynkjs",
     "elysia",
+    "nestjs",
+    "nestjs alternative",
+    "express",
+    "expressjs alternative",
     "bun",
     "framework",
     "typescript",
@@ -18,7 +22,8 @@
     "web-framework",
     "http",
     "api",
-    "nestjs-alternative",
+    "bun-framework",
+    "typescript-decorators",
     "dependency-injection",
     "rest-api",
     "backend",