lieko-express 0.0.11 → 0.0.13

package/lieko-express.d.ts

@@ -1,293 +1,161 @@
-declare namespace Lieko {
-  type PlainObject = Record<string, any>;
+declare module "lieko-express" {
+  import { IncomingMessage, ServerResponse } from "http";
 
-  // Extract params from a path string like "/user/:id/books/:bookId"
-  type ExtractRouteParams<Path extends string> =
-    Path extends `${string}:${infer Param}/${infer Rest}`
-    ? { [k in Param | keyof ExtractRouteParams<Rest>]: string }
-    : Path extends `${string}:${infer Param}`
-    ? { [k in Param]: string }
-    : Record<string, never>;
+  // -------------------------------
+  // Request Extensions
+  // -------------------------------
+  interface LiekoRequest extends IncomingMessage {
+    app: any;
 
-  // -------------- Request / Response types --------------
-  // Minimal subset of http.IncomingMessage / http.ServerResponse for typings
-  interface RequestBase {
-    method: string;
-    url: string;
-    headers: Record<string, string | undefined>;
-    // populated by the framework:
+    // Passport fields
+    user?: any;
+    session?: any;
+
+    // Auth helpers
+    logout(callback?: (err: any) => void): Promise<void> | void;
+
+    // URL helpers
+    originalUrl: string;
+    params: Record<string, string>;
     query: Record<string, any>;
-    params: Record<string, any>;
     body: any;
     files: Record<string, any>;
-    ip?: string;
-    _bodySize?: number;
-    _startTime?: bigint;
-    // raw Node objects (optional)
-    raw?: any;
-  }
-
-  interface ResponseBase {
-    status(code: number): this;
-    json(data: any): void;
-    send(data: any): void;
-    text(data: string): void;
-
-    // headers helpers
-    setHeader(name: string, value: string | number): void;
-    set(name: string | Record<string, string | number>, value?: string | number): void;
-    header(name: string, value: string | number): void;
-    getHeader(name: string): string | number | string[] | undefined;
-    removeHeader(name: string): void;
-    headersSent?: boolean;
-
-    // redirect helpers
-    redirect(url: string): void;
-    redirect(status: number, url: string): void;
-
-    // streaming (optional)
-    write?(chunk: any): void;
-    end?(chunk?: any): void;
-  }
-
-  // Extended Lieko Request and Response with framework helpers
-  interface Request<
-    Params extends Record<string, any> = Record<string, any>,
-    Query extends Record<string, any> = Record<string, any>,
-    Body = any
-  > extends RequestBase {
-    params: Params;
-    query: Query;
-    body: Body;
-    files: Record<string, {
-      filename: string;
-      tempFilePath?: string;
-      data?: Buffer;
-      contentType?: string;
-      size?: number;
-    }>;
-  }
-
-  interface Response extends ResponseBase {
-    // Rich helpers provided by Lieko
-    ok(data?: any, message?: string): void;
-    success: (data?: any, message?: string) => void;
-    created(data?: any, message?: string): void;
-    noContent(): void;
-    accepted(data?: any, message?: string): void;
-
-    badRequest(message?: string, details?: any): void;
-    unauthorized(message?: string, details?: any): void;
-    forbidden(message?: string, details?: any): void;
-    notFound(message?: string, details?: any): void;
-    error(message?: string, status?: number, details?: any): void;
-    fail: (message?: string, status?: number, details?: any) => void;
-    serverError(message?: string, details?: any): void;
-
-    // convenience helpers sometimes provided
-    paginated?(items: any[], total: number, message?: string): void;
-    html?(html: string, status?: number): void;
-
-    // short alias
-    statusCode?: number;
-  }
-
-  // -------------- Handler / Middleware --------------
-  type Handler<
-    Params extends Record<string, any> = Record<string, any>,
-    Query extends Record<string, any> = Record<string, any>,
-    Body = any
-  > = (req: Request<Params, Query, Body>, res: Response, next?: (err?: any) => void) => any | Promise<any>;
-
-  // -------------- CORS / BodyParser options --------------
-  interface CorsOptions {
-    enabled?: boolean;
-    origin?: "*" | string | string[]; // supports wildcard like https://*.example.com
-    methods?: string[]; // allowed methods
-    headers?: string[]; // allowed headers
-    exposedHeaders?: string[];
-    credentials?: boolean;
-    maxAge?: number;
-    debug?: boolean;
-    strictOrigin?: boolean; // 403 if origin not allowed
-    allowPrivateNetwork?: boolean; // Access-Control-Allow-Private-Network
-  }
-
-  interface JsonBodyOptions {
-    limit?: string; // e.g. "10mb"
-    strict?: boolean;
-  }
-
-  interface UrlencodedOptions {
-    limit?: string;
-    extended?: boolean;
-  }
-
-  interface MultipartOptions {
-    limit?: string;
-    tempDir?: string;
-  }
+    xhr: boolean;
+
+    // IP helpers
+    ip: {
+      raw: string | null;
+      ipv4: string | null;
+      ipv6: string | null;
+      display: string;
+    };
+    ips: string[];
 
-  interface BodyParserOptions {
-    json?: JsonBodyOptions;
-    urlencoded?: UrlencodedOptions;
-    multipart?: MultipartOptions;
-  }
+    protocol: string;
+    secure: boolean;
+    hostname: string;
+    subdomains: string[];
 
-  // -------------- Validation / Schema (loose typing to match runtime) --------------
-  // The framework has a validation system — keep it flexible (user can extend)
-  type ValidatorFn = (value: any, field: string, data: any) => { field: string; message: string; type: string } | null;
+    get(name: string): string | undefined;
+    header(name: string): string | undefined;
 
-  interface Validators {
-    required(message?: string): ValidatorFn;
-    requiredTrue(message?: string): ValidatorFn;
-    optional(): ValidatorFn;
-    string(message?: string): ValidatorFn;
-    number(message?: string): ValidatorFn;
-    boolean(message?: string): ValidatorFn;
-    integer(message?: string): ValidatorFn;
-    positive(message?: string): ValidatorFn;
-    negative(message?: string): ValidatorFn;
-    email(message?: string): ValidatorFn;
-    min(minValue: number, message?: string): ValidatorFn;
-    max(maxValue: number, message?: string): ValidatorFn;
-    length(n: number, message?: string): ValidatorFn;
-    minLength(minLength: number, message?: string): ValidatorFn;
-    maxLength(maxLength: number, message?: string): ValidatorFn;
-    pattern(regex: RegExp, message?: string): ValidatorFn;
-    oneOf(allowedValues: any[], message?: string): ValidatorFn;
-    notOneOf(values: any[], message?: string): ValidatorFn;
-    custom(validatorFn: (value: any, data: any) => boolean, message?: string): ValidatorFn;
-    equal(expectedValue: any, message?: string): ValidatorFn;
-    mustBeTrue(message?: string): ValidatorFn;
-    mustBeFalse(message?: string): ValidatorFn;
-    date(message?: string): ValidatorFn;
-    before(limit: string | Date, message?: string): ValidatorFn;
-    after(limit: string | Date, message?: string): ValidatorFn;
-    startsWith(prefix: string, message?: string): ValidatorFn;
-    endsWith(suffix: string, message?: string): ValidatorFn;
-  }
+    accepts(types: string | string[]): string | false;
+    acceptsLanguages(langs: string | string[]): string | false;
+    acceptsCharsets(charsets: string | string[]): string | false;
+    acceptsEncodings(enc: string | string[]): string | false;
 
-  class Schema {
-    constructor(rules: Record<string, ValidatorFn[]>);
-    rules: Record<string, ValidatorFn[]>;
-    fields: Record<string, ValidatorFn[]>;
-    validate(data: Record<string, any>): true | never;
+    is(type: string): boolean;
   }
 
-  function validate(schema: Schema): Handler;
-
-  function validatePartial(schema: Schema): Handler;
+  // -------------------------------
+  // Response Extensions
+  // -------------------------------
+  interface LiekoResponse extends ServerResponse {
+    app: any;
+    locals: Record<string, any>;
 
-  // -------------- Routes / Options --------------
-  interface Route {
-    method: string;
-    path: string;
-    handler: Handler;
-    middlewares: Handler[];
-    pattern: RegExp;
-    groupChain: any[];
-  }
-
-  // -------------- App interface --------------
-  interface App {
-    // route methods (typed path param extraction)
-    get<Path extends string, Q = any, B = any>(
-      path: Path,
-      ...handlers: Handler<ExtractRouteParams<Path>, Q, B>[]
-    ): this;
-
-    post<Path extends string, Q = any, B = any>(
-      path: Path,
-      ...handlers: Handler<ExtractRouteParams<Path>, Q, B>[]
-    ): this;
-
-    put<Path extends string, Q = any, B = any>(
-      path: Path,
-      ...handlers: Handler<ExtractRouteParams<Path>, Q, B>[]
+    status(code: number): this;
+    set(name: string, value: string): this;
+    header(name: string, value: string): this;
+    type(mime: string): this;
+
+    json(data: any): this;
+    send(data: any): this;
+    html(html: string, status?: number): this;
+
+    redirect(url: string, status?: number): this;
+
+    ok(data: any, message?: string): this;
+    success(data: any, message?: string): this;
+    created(data: any, message?: string): this;
+    noContent(): this;
+    accepted(data?: any, message?: string): this;
+    paginated(items: any[], total: number, message?: string): this;
+
+    // Cookie helpers
+    cookie(
+      name: string,
+      value: string,
+      options?: {
+        path?: string;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: "lax" | "strict" | "none";
+        maxAge?: number;
+        expires?: Date;
+        domain?: string;
+      }
     ): this;
 
-    patch<Path extends string, Q = any, B = any>(
-      path: Path,
-      ...handlers: Handler<ExtractRouteParams<Path>, Q, B>[]
+    clearCookie(
+      name: string,
+      options?: {
+        path?: string;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: "lax" | "strict" | "none";
+      }
     ): this;
 
-    delete<Path extends string, Q = any, B = any>(
-      path: Path,
-      ...handlers: Handler<ExtractRouteParams<Path>, Q, B>[]
-    ): this;
+    error(obj: any): this;
+    fail(obj: any): this;
+    badRequest(msg?: string): this;
+    unauthorized(msg?: string): this;
+    forbidden(msg?: string): this;
+    notFound(msg?: string): this;
+    serverError(msg?: string): this;
+  }
 
-    all<Path extends string, Q = any, B = any>(
-      path: Path,
-      ...handlers: Handler<ExtractRouteParams<Path>, Q, B>[]
+  // -------------------------------
+  // Handler Types
+  // -------------------------------
+  type LiekoHandler = (
+    req: LiekoRequest,
+    res: LiekoResponse,
+    next: (err?: any) => void
+  ) => any;
+
+  type LiekoErrorHandler = (
+    err: any,
+    req: LiekoRequest,
+    res: LiekoResponse,
+    next: (err?: any) => void
+  ) => any;
+
+  // -------------------------------
+  // Router / App Class
+  // -------------------------------
+  class LiekoExpress {
+    constructor();
+
+    get(path: string, ...handlers: LiekoHandler[]): this;
+    post(path: string, ...handlers: LiekoHandler[]): this;
+    put(path: string, ...handlers: LiekoHandler[]): this;
+    patch(path: string, ...handlers: LiekoHandler[]): this;
+    delete(path: string, ...handlers: LiekoHandler[]): this;
+    all(path: string, ...handlers: LiekoHandler[]): this;
+
+    use(mw: LiekoHandler): this;
+    use(path: string, mw: LiekoHandler): this;
+    use(path: string, router: LiekoExpress): this;
+    use(path: string, mw: LiekoHandler, router: LiekoExpress): this;
+
+    group(
+      basePath: string,
+      ...middlewares: LiekoHandler[]
     ): this;
 
-    // middleware
-    use(handler: Handler | App): this;
-    use(path: string, handler: Handler | App): this;
+    errorHandler(handler: LiekoErrorHandler): this;
+    notFound(handler: LiekoHandler): this;
 
-    // grouping
-    group(basePath: string, callback: (group: App) => void): this;
+    set(name: string, value: any): this;
+    get(setting: string): any;
 
-    // CORS
-    cors(options?: Partial<CorsOptions>): Handler;
-
-    // body parser
-    bodyParser: {
-      json(options?: JsonBodyOptions): Handler;
-      urlencoded(options?: UrlencodedOptions): Handler;
-      multipart(options?: MultipartOptions): Handler;
-    };
-
-    // static files
-    static(root: string, options?: { maxAge?: number; index?: string }): Handler;
-
-    // error handler
-    error(res: Response, obj: any): void;
-
-    // settings
-    set(key: string, value: any): this;
-    get(key: string): any;
-
-    // debug
-    debug(value?: boolean | string): this;
-
-    // utilities
-    listRoutes(): { method: string; path: string | string[]; middlewares: number }[];
-    printRoutes(): void;
-
-    // server control
     listen(port: number, host?: string, callback?: () => void): any;
-    listen(...args: any[]): any;
-  }
-
-  // -------------- Factory / Constructor --------------
-  interface ConstructorOptions {
-    // initial options
-    cors?: Partial<CorsOptions>;
-    bodyParser?: Partial<BodyParserOptions>;
-    trustProxy?: boolean | string | string[];
-    debug?: boolean;
-    allowTrailingSlash?: boolean;
-    strictTrailingSlash?: boolean;
-    // other global options
-    [key: string]: any;
   }
 
-  interface LiekoStatic {
-    (opts?: ConstructorOptions): App;
+  function Lieko(): LiekoExpress;
+  function Router(): LiekoExpress;
 
-    // expose helpers statically if present in runtime
-    Router: () => App;
-    Schema: typeof Schema;
-    schema: (...args: any[]) => Schema;
-    validators: Validators;
-    validate: typeof validate;
-    validatePartial: (schema: Schema) => Handler;
-    ValidationError: typeof ValidationError;
-    static: (root: string, options?: { maxAge?: number; index?: string }) => Handler;
-  }
+  export = Lieko;
 }
-
-declare const Lieko: Lieko.LiekoStatic;
-export = Lieko;

package/lieko-express.js

@@ -1105,6 +1105,7 @@ ${cyan}    (req, res, next) => {
     }
 
     req.originalUrl = req.url;
+    req.path = req.url.split('?')[0];
     req.xhr = (req.headers['x-requested-with'] || '').toLowerCase() === 'xmlhttprequest';
 
     req.get = (name) => {
@@ -1200,6 +1201,26 @@ ${cyan}    (req, res, next) => {
       if (t === 'multipart') return ct.includes('multipart');
       return false;
     };
+
+    /**
+     * Passport-compatible logout (Passport 0.6+ / 0.7)
+     * This ensures logout(cb) always calls cb(null) and never overwrites Express res
+     */
+    req.logout = function logout(callback) {
+      req.user = null;
+
+      // Remove passport session field if it exists
+      if (req.session && req.session.passport) {
+        delete req.session.passport;
+      }
+
+      // Passport v0.6+ expects async logout
+      if (typeof callback === "function") {
+        return callback(null);
+      }
+
+      return Promise.resolve();
+    };
   }
 
   _enhanceResponse(req, res) {
@@ -1478,6 +1499,54 @@ ${cyan}    (req, res, next) => {
       return res.status(500).error(msg);
     };
 
+    res.cookie = (name, value, options = {}) => {
+      const opts = {
+        path: '/',
+        httpOnly: true,
+        secure: req.secure || false,
+        sameSite: 'lax',
+        maxAge: null,
+        expires: null,
+        ...options
+      };
+
+      let cookie = `${name}=${encodeURIComponent(value)}`;
+
+      if (opts.maxAge) cookie += `; Max-Age=${Math.floor(opts.maxAge / 1000)}`;
+      if (opts.expires) cookie += `; Expires=${opts.expires.toUTCString()}`;
+      cookie += `; Path=${opts.path}`;
+      if (opts.domain) cookie += `; Domain=${opts.domain}`;
+      if (opts.httpOnly) cookie += '; HttpOnly';
+      if (opts.secure) cookie += '; Secure';
+      if (opts.sameSite) cookie += `; SameSite=${opts.sameSite}`;
+
+      res.setHeader('Set-Cookie', cookie);
+      return res;
+    };
+
+    res.clearCookie = (name, options = {}) => {
+      if (responseSent) return res;
+
+      const opts = {
+        path: '/',
+        httpOnly: true,
+        secure: req.secure || false,
+        sameSite: 'lax',
+        ...options
+      };
+
+      const cookieValue = `${name}=; Max-Age=0; Expires=${new Date(0).toUTCString()}; Path=${opts.path}`;
+
+      let header = cookieValue;
+
+      if (opts.httpOnly) header += '; HttpOnly';
+      if (opts.secure) header += '; Secure';
+      if (opts.sameSite && opts.sameSite !== 'none') header += `; SameSite=${opts.sameSite}`;
+
+      res.setHeader('Set-Cookie', header);
+      return res;
+    };
+
     const originalEnd = res.end.bind(res);
 
     res.end = (...args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lieko-express",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "repository": {
     "type": "git",
     "url": "https://github.com/eiwSrvt/lieko-express"