@nauth-toolkit/core 0.1.0 → 0.1.5

package/LICENSE

@@ -0,0 +1,90 @@
+NAUTH TOOLKIT EARLY ACCESS LICENSE
+Version 1.0 (December 2025)
+
+================================================================================
+FUTURE OPEN SOURCE NOTICE
+================================================================================
+NAuth Toolkit will transition to an open-source license (MIT or Apache 2.0) for
+core authentication features once the project reaches production readiness.
+
+This Early Access License is temporary and designed to:
+• Allow developers to build with nauth-toolkit during preview/beta
+• Provide clear expectations during the pre-release phase
+• Enable feedback and real-world testing before GA
+
+We're committed to keeping core auth free and open source. Premium features
+(enterprise SSO, advanced compliance, hosted options) will be offered separately
+under fair commercial terms.
+
+================================================================================
+EARLY ACCESS LICENSE TERMS
+================================================================================
+
+1. Grant of Use
+   You are granted a free, non-exclusive, non-transferable license to:
+   - Install and use nauth-toolkit packages in development, testing, staging,
+     and production environments
+   - Modify the code for your own internal use
+   - Deploy applications using nauth-toolkit to serve your users
+
+   You may NOT:
+   - Redistribute NAuth Toolkit as a standalone product or service
+   - Sell, sublicense, or offer NAuth Toolkit as part of a competing auth
+     platform or toolkit
+   - Remove or alter copyright notices
+
+2. No Fees During Early Access
+   There are no license fees, subscription costs, or usage charges during the
+   Early Access period. You may use nauth-toolkit freely for commercial and
+   non-commercial purposes within the terms of this license.
+
+3. Production Use
+   Production use is permitted but comes with standard early-access caveats:
+   - Features and APIs may change between preview releases
+   - Support is community-based (GitHub issues/discussions)
+   - No SLA or guaranteed uptime (you run it on your infrastructure)
+
+   We recommend thorough testing and having rollback plans for critical systems.
+
+4. Future Transition
+   When nauth-toolkit releases v1.0 GA:
+   - Core packages will adopt an open-source license (MIT or Apache 2.0)
+   - Your existing deployments will continue to work
+   - Premium features (if any) will be clearly documented with separate licensing
+   - No forced upgrades or surprise fees
+
+5. Ownership
+   NAuth Toolkit is developed and maintained by Noorix Digital Solutions.
+   You retain full ownership of your applications and data.
+
+6. Data and Privacy
+   NAuth Toolkit runs in YOUR infrastructure and database. You control all data.
+   You are responsible for compliance with applicable data protection laws.
+
+7. Disclaimer of Warranty
+   THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+8. Limitation of Liability
+   IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY INDIRECT, INCIDENTAL,
+   SPECIAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES, INCLUDING BUT NOT LIMITED TO LOSS
+   OF PROFITS, REVENUE, DATA, OR USE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+   DAMAGES.
+
+9. Termination
+   This license remains in effect until:
+   - You stop using nauth-toolkit, or
+   - The project transitions to open source (at which point the new license applies)
+
+   If you breach these terms, your license terminates and you must stop using the
+   software.
+
+10. Contact and Support
+    - Documentation: https://nauth.dev
+    - Issues/Discussions: GitHub (when public repository launches)
+    - Commercial inquiries: Contact admin@noorix.com
+
+================================================================================
+Thank you for being an early adopter. Your feedback shapes the future of NAuth.
+================================================================================

package/README.md

@@ -0,0 +1,9 @@
+# @nauth-toolkit/core
+
+Core authentication toolkit for Node JS
+
+## Preview Release Notice
+
+**This is a preview release for internal testing. Do not use in production yet.**
+
+This package is part of nauth-toolkit and is currently in early access/preview. Features and APIs may change between releases. For production use, please wait for the stable v1.0 release.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nauth-toolkit/core",
-  "version": "0.1.0",
-  "description": "Core authentication toolkit for NestJS",
+  "version": "0.1.5",
+  "description": "Core authentication toolkit for Node JS",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -63,11 +63,16 @@
     "access": "public",
     "tag": "preview"
   },
-  "license": "SEE LICENSE IN LICENSE",
+  "license": "UNLICENSED",
   "keywords": [
     "nestjs",
     "authentication",
     "jwt",
     "typeorm"
+  ],
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
   ]
 }

package/jest.config.js

@@ -1,15 +0,0 @@
-module.exports = {
-  moduleFileExtensions: ['js', 'json', 'ts'],
-  rootDir: 'src',
-  testRegex: '.*\\.spec\\.ts$',
-  transform: {
-    '^.+\\.(t|j)s$': 'ts-jest',
-  },
-  collectCoverageFrom: ['**/*.(t|j)s'],
-  coverageDirectory: '../coverage',
-  testEnvironment: 'node',
-  // Transform ESM modules like jose
-  transformIgnorePatterns: ['node_modules/(?!(jose)/)'],
-  // Setup reflect-metadata for TypeORM
-  setupFilesAfterEnv: ['<rootDir>/../jest.setup.ts'],
-};

package/jest.setup.ts

@@ -1,6 +0,0 @@
-/**
- * Jest setup file for reflect-metadata support
- * Required for TypeORM decorators to work in tests
- */
-import 'reflect-metadata';
-

package/src/adapters/database-columns.ts

@@ -1,165 +0,0 @@
-import { Column, ColumnOptions } from 'typeorm';
-
-/**
- * Database-Agnostic Column Decorators
- *
- * Provides column decorators that automatically adapt to different database types.
- * Uses the database adapter to determine appropriate column types.
- *
- * @example
- * ```typescript
- * @Entity()
- * export class User {
- *   @UuidColumn()
- *   id!: string;
- *
- *   @JsonColumn()
- *   metadata?: Record<string, any>;
- *
- *   @ArrayColumn()
- *   tags?: string[];
- * }
- * ```
- */
-
-/**
- * Create UUID column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function UuidColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    // This would be replaced with actual adapter-based logic
-    // For now, use PostgreSQL default
-    const columnOptions: ColumnOptions = {
-      type: 'uuid',
-      ...options,
-    };
-
-    // In a real implementation, this would use the injected adapter
-    // to determine the correct column type
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create JSON column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function JsonColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'jsonb', // PostgreSQL default
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create array column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function ArrayColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'simple-array', // TypeORM handles this
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create timestamp column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function TimestampColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'timestamp',
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create boolean column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function BooleanColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'boolean',
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create integer column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function IntegerColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'int',
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create varchar column with database-appropriate type
- *
- * @param length - Maximum length
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function VarcharColumn(length: number, options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'varchar',
-      length,
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}
-
-/**
- * Create text column with database-appropriate type
- *
- * @param options - Additional column options
- * @returns Column decorator
- */
-export function TextColumn(options?: Partial<ColumnOptions>) {
-  return function (target: Record<string, unknown>, propertyKey: string) {
-    const columnOptions: ColumnOptions = {
-      type: 'text',
-      ...options,
-    };
-
-    return Column(columnOptions)(target, propertyKey);
-  };
-}

package/src/adapters/express.adapter.ts

@@ -1,385 +0,0 @@
-/**
- * Express Framework Adapter
- *
- * Adapts NAuth to work with Express.js (4.x and 5.x compatible).
- *
- * **Context Management:**
- * - First middleware (clientInfo) initializes AsyncLocalStorage context
- * - Context automatically propagates through Express middleware chain
- * - Route handlers have automatic context access (no wrapper needed)
- *
- * **Express 5.x Compatibility:**
- * - Uses req.hostname instead of deprecated req.host
- * - Handles async middleware errors automatically
- * - Compatible with new path matching behavior
- */
-
-import {
-  NAuthAdapter,
-  NAuthRequest,
-  NAuthResponse,
-  NAuthCookieOptions,
-  NAuthRequestAttributes,
-  NAuthMiddlewareHandler,
-  NAuthResponseInterceptorHandler,
-  NAuthRouteHandler,
-  MiddlewareOptions,
-} from '../platform/interfaces';
-import { ContextStorage } from '../utils/context-storage';
-
-// ============================================================================
-// Express Adapter
-// ============================================================================
-
-/**
- * Express Adapter Implementation
- *
- * Provides NAuth integration for Express.js applications.
- */
-export class ExpressAdapter implements NAuthAdapter {
-  public readonly name = 'ExpressAdapter';
-
-  /**
-   * Register a middleware handler
-   *
-   * Wraps the generic NAuth handler into Express middleware format.
-   * Handles context initialization for the first middleware.
-   */
-  public registerMiddleware(
-    name: string,
-    handler: NAuthMiddlewareHandler,
-    options?: MiddlewareOptions,
-  ): ExpressMiddleware {
-    const initializesContext = options?.initializesContext || name === 'clientInfo';
-
-    return async (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction): Promise<void> => {
-      // Ensure we have attribute storage
-      if (!req._nauthAttributes) {
-        req._nauthAttributes = {};
-      }
-
-      const nauthReq = new ExpressRequestWrapper(req);
-      const nauthRes = new ExpressResponseWrapper(res);
-
-      try {
-        if (initializesContext) {
-          // First middleware - initialize context
-          await ContextStorage.run(async () => {
-            await this.executeHandler(handler, nauthReq, nauthRes, next);
-          });
-        } else {
-          // Subsequent middleware - context should exist from first middleware
-          await this.executeHandler(handler, nauthReq, nauthRes, next);
-        }
-      } catch (error) {
-        next(error);
-      }
-    };
-  }
-
-  /**
-   * Execute handler with proper async flow control
-   */
-  private async executeHandler(
-    handler: NAuthMiddlewareHandler,
-    req: NAuthRequest,
-    res: NAuthResponse,
-    next: ExpressNextFunction,
-  ): Promise<void> {
-    let nextCalled = false;
-    const nextError: unknown = undefined;
-
-    const wrappedNext = (): void => {
-      nextCalled = true;
-    };
-
-    await handler(req, res, wrappedNext);
-
-    // Only call Express next if handler called next and no response sent
-    if (nextCalled && !res.isSent()) {
-      next(nextError);
-    }
-  }
-
-  /**
-   * Register a response interceptor
-   *
-   * Uses res.json monkey-patching to intercept JSON responses.
-   * This is the standard pattern for Express response interception.
-   */
-  public registerResponseInterceptor(handler: NAuthResponseInterceptorHandler): ExpressMiddleware {
-    return (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction): void => {
-      // Ensure we have attribute storage
-      if (!req._nauthAttributes) {
-        req._nauthAttributes = {};
-      }
-
-      const originalJson = res.json.bind(res);
-
-      // Monkey-patch res.json
-      res.json = function (body: unknown): ExpressResponse {
-        const nauthReq = new ExpressRequestWrapper(req);
-        const nauthRes = new ExpressResponseWrapper(res);
-
-        // Execute interceptor synchronously wrapped in promise handling
-        Promise.resolve(handler(nauthReq, nauthRes, body))
-          .then((modifiedBody) => {
-            // Restore original json to prevent recursion
-            res.json = originalJson;
-            return originalJson(modifiedBody);
-          })
-          .catch((error) => {
-            // On error, send original body (error handled gracefully)
-            res.json = originalJson;
-            return originalJson(body);
-          });
-
-        // Return res for chaining (Express 5 style)
-        return res;
-      };
-
-      next();
-    };
-  }
-
-  /**
-   * Wrap a route handler
-   *
-   * For Express, this provides:
-   * - NAuthRequest/NAuthResponse wrappers
-   * - Automatic error handling
-   * - Context is automatically available (no restoration needed)
-   */
-  public wrapRouteHandler<T>(handler: NAuthRouteHandler<T>): ExpressMiddleware {
-    return async (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction): Promise<void> => {
-      // Ensure we have attribute storage
-      if (!req._nauthAttributes) {
-        req._nauthAttributes = {};
-      }
-
-      const nauthReq = new ExpressRequestWrapper(req);
-      const nauthRes = new ExpressResponseWrapper(res);
-
-      try {
-        const result = await handler(nauthReq, nauthRes);
-
-        // If handler returned a value and response not sent, send it as JSON
-        if (result !== undefined && !res.headersSent) {
-          res.json(result);
-        }
-      } catch (error) {
-        next(error);
-      }
-    };
-  }
-}
-
-// ============================================================================
-// Express Request Wrapper
-// ============================================================================
-
-/**
- * Wraps Express request into NAuthRequest interface
- */
-class ExpressRequestWrapper implements NAuthRequest {
-  constructor(private readonly req: ExpressRequest) {}
-
-  get raw(): unknown {
-    return this.req;
-  }
-
-  get method(): string {
-    return this.req.method.toUpperCase();
-  }
-
-  get path(): string {
-    // Express provides path without query string
-    return this.req.path || this.req.url.split('?')[0];
-  }
-
-  get url(): string {
-    return this.req.originalUrl || this.req.url;
-  }
-
-  get body(): Record<string, unknown> {
-    return (this.req.body as Record<string, unknown>) || {};
-  }
-
-  get query(): Record<string, unknown> {
-    return (this.req.query as Record<string, unknown>) || {};
-  }
-
-  get params(): Record<string, string> {
-    return (this.req.params as Record<string, string>) || {};
-  }
-
-  get headers(): Record<string, string | string[] | undefined> {
-    return this.req.headers as Record<string, string | string[] | undefined>;
-  }
-
-  get cookies(): Record<string, string | undefined> {
-    // Express with cookie-parser middleware
-    return (this.req.cookies as Record<string, string | undefined>) || {};
-  }
-
-  get ip(): string {
-    // Express 4.x and 5.x compatible
-    // Trust proxy must be configured for X-Forwarded-For
-    return this.req.ip || this.req.socket?.remoteAddress || '0.0.0.0';
-  }
-
-  get attributes(): NAuthRequestAttributes {
-    // Return isolated storage, not raw request
-    return this.req._nauthAttributes || {};
-  }
-
-  public getHeader(name: string): string | undefined {
-    // Express provides req.get() for case-insensitive header lookup
-    const val = this.req.get ? this.req.get(name) : this.req.headers[name.toLowerCase()];
-    if (Array.isArray(val)) return val[0];
-    return val;
-  }
-}
-
-// ============================================================================
-// Express Response Wrapper
-// ============================================================================
-
-/**
- * Wraps Express response into NAuthResponse interface
- */
-class ExpressResponseWrapper implements NAuthResponse {
-  constructor(private readonly res: ExpressResponse) {}
-
-  get raw(): unknown {
-    return this.res;
-  }
-
-  public status(code: number): this {
-    this.res.status(code);
-    return this;
-  }
-
-  public header(name: string, value: string | string[]): this {
-    this.res.setHeader(name, value);
-    return this;
-  }
-
-  public setCookie(name: string, value: string, options?: NAuthCookieOptions): this {
-    // Express provides res.cookie()
-    if (typeof this.res.cookie === 'function') {
-      this.res.cookie(name, value, this.convertCookieOptions(options));
-    }
-    return this;
-  }
-
-  public clearCookie(name: string, options?: NAuthCookieOptions): this {
-    if (typeof this.res.clearCookie === 'function') {
-      this.res.clearCookie(name, this.convertCookieOptions(options));
-    }
-    return this;
-  }
-
-  public send(body: unknown): void {
-    this.res.send(body);
-  }
-
-  public json(body: unknown): void {
-    this.res.json(body);
-  }
-
-  public redirect(url: string, status?: number): void {
-    if (status) {
-      this.res.redirect(status, url);
-    } else {
-      this.res.redirect(url);
-    }
-  }
-
-  public isSent(): boolean {
-    return this.res.headersSent;
-  }
-
-  /**
-   * Convert NAuth cookie options to Express cookie options
-   */
-  private convertCookieOptions(options?: NAuthCookieOptions): Record<string, unknown> {
-    if (!options) return {};
-
-    return {
-      httpOnly: options.httpOnly,
-      secure: options.secure,
-      sameSite: options.sameSite,
-      domain: options.domain,
-      path: options.path,
-      maxAge: options.maxAge,
-      expires: options.expires,
-    };
-  }
-}
-
-// ============================================================================
-// Express Type Definitions (minimal, for internal use)
-// ============================================================================
-
-/**
- * Express Request type (minimal interface for our needs)
- * Compatible with Express 4.x and 5.x
- */
-interface ExpressRequest {
-  method: string;
-  path: string;
-  url: string;
-  originalUrl: string;
-  body: unknown;
-  query: unknown;
-  params: unknown;
-  headers: Record<string, string | string[] | undefined>;
-  cookies?: Record<string, string>;
-  ip: string;
-  socket?: { remoteAddress?: string };
-  get?(name: string): string | undefined;
-
-  /** NAuth attribute storage - isolated from raw request */
-  _nauthAttributes?: NAuthRequestAttributes;
-}
-
-/**
- * Express Response type (minimal interface for our needs)
- * Compatible with Express 4.x and 5.x
- */
-interface ExpressResponse {
-  status(code: number): this;
-  setHeader(name: string, value: string | string[]): void;
-  cookie(name: string, value: string, options?: Record<string, unknown>): void;
-  clearCookie(name: string, options?: Record<string, unknown>): void;
-  send(body: unknown): void;
-  json(body: unknown): this;
-  redirect(status: number, url: string): void;
-  redirect(url: string): void;
-  headersSent: boolean;
-}
-
-/**
- * Express NextFunction type
- */
-type ExpressNextFunction = (err?: unknown) => void;
-
-/**
- * Express middleware signature
- */
-type ExpressMiddleware = (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => void | Promise<void>;
-
-// ============================================================================
-// Type Exports for Consumer Applications
-// ============================================================================
-
-/**
- * Express middleware type for use with app.use()
- *
- * Consumer apps should cast nauth.middleware.* to this type:
- * ```typescript
- * app.use(nauth.middleware.clientInfo as ExpressMiddlewareType);
- * ```
- */
-export type ExpressMiddlewareType = (req: unknown, res: unknown, next: (err?: unknown) => void) => void | Promise<void>;