mulink 1.0.0

package/dist/lib/version-checker-BWdifiXN.d.ts

@@ -0,0 +1,576 @@
+import { OpenAPIV3, OpenAPIV2 } from 'openapi-types';
+import { z } from 'zod';
+
+interface BridgeConfiguration {
+    /** OpenAPI schema URL or file path */
+    schema: string;
+    /** Output directory for generated files */
+    outputDir: string;
+    /** Framework configuration */
+    framework: FrameworkConfiguration;
+    /** API configuration */
+    api: ApiConfiguration;
+    /** Authentication configuration */
+    auth?: AuthConfiguration;
+    /** Caching configuration */
+    cache?: CacheConfiguration;
+    /** File upload configuration */
+    uploads?: UploadConfiguration;
+    /** Development options */
+    dev?: DevelopmentConfiguration;
+    /** Plugin configurations */
+    plugins?: PluginConfiguration[];
+    /** Custom type mappings */
+    typeMappings?: Record<string, string>;
+    /** Generation options */
+    generation?: GenerationConfiguration;
+}
+interface FrameworkConfiguration {
+    type: 'nextjs';
+    version?: string;
+    router: 'app' | 'pages';
+    features: {
+        serverActions: boolean;
+        middleware: boolean;
+        streaming: boolean;
+        revalidation: boolean;
+    };
+    /** Streaming configuration */
+    streaming?: StreamingConfiguration;
+}
+interface ApiConfiguration {
+    baseUrl: string;
+    timeout: number;
+    retries: number;
+    headers?: Record<string, string>;
+    interceptors?: {
+        request?: string[];
+        response?: string[];
+    };
+    /** Next.js 16: Custom user agent for fetch requests */
+    userAgent?: string;
+    /** Custom error handler configuration */
+    errorHandling?: ErrorHandlingConfiguration;
+    /** Custom middleware imports */
+    customMiddleware?: CustomMiddlewareConfiguration[];
+}
+interface ErrorHandlingConfiguration {
+    /** Enable automatic auth error handling */
+    enableAuthErrorHandling?: boolean;
+    /** Path to custom auth error handler (default: @/lib/auth-error-handler) */
+    authErrorHandlerPath?: string;
+    /** Generate auth error handler if it doesn't exist */
+    generateAuthErrorHandler?: boolean;
+    /** Custom error handler paths */
+    customHandlers?: Record<string, string>;
+}
+interface CustomMiddlewareConfiguration {
+    /** Middleware name */
+    name: string;
+    /** Import path for the middleware */
+    importPath: string;
+    /** Whether to include in default middleware stack */
+    includeInDefault?: boolean;
+    /** Middleware priority (lower = earlier in stack) */
+    priority?: number;
+}
+interface AuthConfiguration {
+    enabled: boolean;
+    provider: 'next-auth' | 'clerk' | 'custom';
+    middleware?: boolean;
+    publicPaths?: string[];
+    /** Path to auth utility (default: @/lib/auth) */
+    authPath?: string;
+    /** Custom auth token getter function name */
+    tokenGetter?: string;
+    /** OAuth providers configuration */
+    oauth?: {
+        enabled: boolean;
+        providers?: ('google' | 'github' | 'discord' | 'microsoft' | 'apple')[];
+        /** Custom OAuth callback URL */
+        callbackUrl?: string;
+    };
+    /** MFA (Multi-Factor Authentication) configuration */
+    mfa?: {
+        enabled: boolean;
+        /** Support TOTP (Time-based One-Time Password) */
+        totp?: boolean;
+        /** Support backup codes */
+        backupCodes?: boolean;
+    };
+    /** Passkeys (WebAuthn) configuration */
+    passkeys?: {
+        enabled: boolean;
+        /** Require user verification */
+        requireUserVerification?: boolean;
+        /** Timeout in milliseconds */
+        timeout?: number;
+    };
+    /** Session configuration */
+    session?: {
+        /** Session strategy: 'jwt' or 'database' */
+        strategy?: 'jwt' | 'database';
+        /** Maximum session age in seconds */
+        maxAge?: number;
+        /** JWT maximum age in seconds */
+        jwtMaxAge?: number;
+    };
+    /** Token refresh configuration */
+    tokenRefresh?: {
+        /** Enable automatic token refresh */
+        enabled?: boolean;
+        /** Refresh token before expiry (in seconds) */
+        refreshBeforeExpiry?: number;
+    };
+    /** Account status checking */
+    accountStatus?: {
+        /** Check account status on token refresh */
+        checkOnRefresh?: boolean;
+        /** Auto-logout on account suspension */
+        autoLogoutOnSuspension?: boolean;
+    };
+}
+interface CacheConfiguration {
+    strategy: 'memory' | 'redis' | 'database';
+    ttl: number;
+    tags: boolean;
+    revalidation: 'time' | 'on-demand' | 'both';
+    /** Next.js 16: Enable cache tags for granular invalidation */
+    cacheTags?: boolean;
+    /** Next.js 16: Enable connection keep-alive for persistent connections */
+    persistentConnections?: boolean;
+}
+interface DevelopmentConfiguration {
+    logging: boolean;
+    validation: boolean;
+    mocking: boolean;
+    watch: boolean;
+}
+interface PluginConfiguration {
+    name: string;
+    options?: Record<string, unknown>;
+}
+interface GenerationConfiguration {
+    typescript: boolean;
+    strict: boolean;
+    comments: boolean;
+    examples: boolean;
+    tests: boolean;
+}
+interface UploadConfiguration {
+    enabled: boolean;
+    strategy: 'standard' | 'external' | 'presigned';
+    provider?: 'uploadthing' | 'vercel-blob' | 'standard' | 's3' | 'minio';
+    compression?: {
+        enabled: boolean;
+        formats?: ('gzip' | 'webp' | 'brotli')[];
+    };
+    security?: {
+        maxSize?: string;
+        allowedTypes?: string[];
+        scan?: 'clamav' | 'none';
+    };
+    /** Enable presigned URL uploads (direct to S3/MinIO) */
+    presignedUploads?: {
+        enabled: boolean;
+        /** Endpoint path for generating presigned URLs (e.g., '/api/v1/files/presign-upload') */
+        presignEndpoint?: string;
+        /** Fallback to backend upload if presigned upload fails */
+        fallbackToBackend?: boolean;
+    };
+    /** Progress tracking configuration */
+    progressTracking?: {
+        enabled: boolean;
+        /** Use XMLHttpRequest for better progress tracking (default: true) */
+        useXHR?: boolean;
+    };
+}
+interface StreamingConfiguration {
+    enabled: boolean;
+    /** Support for Server-Sent Events (SSE) */
+    sse?: {
+        enabled: boolean;
+        /** Auto-reconnect on connection loss */
+        autoReconnect?: boolean;
+        /** Reconnect delay in milliseconds */
+        reconnectDelay?: number;
+        /** Maximum reconnect attempts */
+        maxReconnectAttempts?: number;
+    };
+    /** Support for WebSocket streaming */
+    websocket?: {
+        enabled: boolean;
+        /** WebSocket URL pattern */
+        urlPattern?: string;
+    };
+    /** Support for HTTP streaming (ReadableStream) */
+    httpStreaming?: {
+        enabled: boolean;
+    };
+}
+type OpenApiDocument = OpenAPIV3.Document | OpenAPIV2.Document;
+interface ParsedApiSchema {
+    version: '2.0' | '3.0' | '3.1';
+    document: OpenAPIV3.Document;
+    openApiSpec: OpenAPIV3.Document;
+    endpoints: ApiEndpointDefinition[];
+    schemas: SchemaDefinition[];
+    security: SecuritySchemeDefinition[];
+    servers: ServerDefinition[];
+    metadata: SchemaMetadata;
+}
+interface ApiEndpointDefinition {
+    id: string;
+    path: string;
+    method: HttpMethod;
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags: string[];
+    parameters: ParameterDefinition[];
+    requestBody?: RequestBodyDefinition;
+    responses: ApiResponseDefinition[];
+    security: SecurityRequirement[];
+    deprecated: boolean;
+    metadata: EndpointMetadata;
+}
+interface ParameterDefinition {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required: boolean;
+    schema: z.ZodSchema;
+    description?: string;
+    example?: unknown;
+    deprecated: boolean;
+}
+interface RequestBodyDefinition {
+    required: boolean;
+    description?: string;
+    content: MediaTypeDefinition[];
+}
+interface MediaTypeDefinition {
+    type: string;
+    schema: z.ZodSchema;
+    examples?: Record<string, unknown>;
+}
+interface ApiResponseDefinition {
+    statusCode: string;
+    description: string;
+    content?: MediaTypeDefinition[];
+    headers?: Record<string, ParameterDefinition>;
+}
+interface SchemaDefinition {
+    name: string;
+    schema: z.ZodSchema;
+    description?: string;
+    example?: unknown;
+    deprecated: boolean;
+}
+interface SecuritySchemeDefinition {
+    name: string;
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: unknown;
+}
+interface ServerDefinition {
+    url: string;
+    description?: string;
+    variables?: Record<string, unknown>;
+}
+interface SchemaMetadata {
+    title: string;
+    version: string;
+    description?: string;
+    contact?: unknown;
+    license?: unknown;
+    externalDocs?: unknown;
+    timestamp: number;
+}
+interface EndpointMetadata {
+    requiresAuth: boolean;
+    cacheStrategy: CacheStrategy;
+    revalidationTags: string[];
+    rateLimit?: RateLimit;
+    timeout?: number;
+    streaming: boolean;
+    fileUpload: boolean;
+}
+interface SecurityRequirement {
+    [name: string]: string[];
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+type CacheStrategy = 'no-cache' | 'force-cache' | 'revalidate' | 'default';
+interface RateLimit {
+    requests: number;
+    window: number;
+}
+interface GenerationContext {
+    config: BridgeConfiguration;
+    schema: ParsedApiSchema;
+    outputDir: string;
+    timestamp: number;
+}
+interface GeneratedFile {
+    path: string;
+    content: string;
+    type: 'typescript' | 'javascript' | 'json';
+    metadata?: FileMetadata;
+}
+interface FileMetadata {
+    exports: string[];
+    imports: string[];
+    dependencies: string[];
+}
+declare class BridgeError extends Error {
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(message: string, code: string, details?: unknown);
+}
+declare class ValidationError extends BridgeError {
+    readonly errors: z.ZodError;
+    constructor(message: string, errors: z.ZodError);
+}
+declare class SchemaParseError extends BridgeError {
+    readonly schemaUrl: string;
+    constructor(message: string, schemaUrl: string);
+}
+declare class GenerationError extends BridgeError {
+    readonly file?: string;
+    constructor(message: string, file?: string);
+}
+interface BridgePlugin {
+    name: string;
+    version: string;
+    transform(content: string, context: GenerationContext): Promise<string>;
+    validate?(config: BridgeConfiguration): Promise<void>;
+    setup?(context: GenerationContext): Promise<void>;
+    cleanup?(context: GenerationContext): Promise<void>;
+}
+interface ClientConfiguration {
+    baseUrl: string;
+    timeout?: number;
+    retries?: number;
+    headers?: Record<string, string>;
+    auth?: {
+        type: 'bearer' | 'apiKey' | 'basic';
+        token?: string;
+        apiKey?: string;
+        username?: string;
+        password?: string;
+    };
+}
+interface RequestConfiguration extends Omit<RequestInit, 'cache' | 'priority'> {
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    enableCache?: boolean;
+    deduplication?: boolean;
+    validation?: boolean;
+    requestCache?: RequestCache;
+    priority?: number;
+    circuitBreaker?: boolean;
+    streaming?: boolean;
+    compression?: boolean;
+    prefetch?: boolean;
+    background?: boolean;
+    /** Next.js 16: Cache tags for granular invalidation */
+    cacheTags?: string[];
+    /** Next.js 16: Connection type for persistent connections */
+    connection?: 'keep-alive' | 'close';
+    /** Next.js 16: Update cache tags dynamically */
+    updateTag?: (tag: string) => void;
+}
+interface ClientResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    cached?: boolean;
+    retryCount?: number;
+    responseTime?: number;
+    fromCache?: boolean;
+    compressed?: boolean;
+    etag?: string;
+}
+interface StreamingResponse<T = any> {
+    data: AsyncIterable<T>;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    controller: AbortController;
+}
+
+declare class BridgeCore {
+    private readonly logger;
+    private readonly schemaParser;
+    private readonly fileManager;
+    constructor();
+    generate(configuration: BridgeConfiguration): Promise<void>;
+    private validateConfiguration;
+    private generateFiles;
+    private writeFiles;
+    private logGenerationSummary;
+    validateSchema(schemaUrl: string): Promise<boolean>;
+    getSchemaInfo(schemaUrl: string): Promise<ParsedApiSchema['metadata']>;
+    clearCache(): void;
+}
+
+declare class OpenApiSchemaParser {
+    private schemaCache;
+    parse(schemaUrl: string): Promise<ParsedApiSchema>;
+    private fetchSchema;
+    private parseDocument;
+    private detectVersion;
+    private normalizeDocument;
+    private convertV2ToV3;
+    private extractEndpoints;
+    private extractParameters;
+    private extractRequestBody;
+    private extractResponses;
+    private extractSchemas;
+    private extractSecurity;
+    private extractServers;
+    private extractMetadata;
+    private extractEndpointMetadata;
+    private hasFileUpload;
+    private resolveReference;
+    private convertSchemaToZod;
+    clearCache(): void;
+}
+
+declare class ConfigurationLoader {
+    load(configPath?: string): Promise<BridgeConfiguration>;
+    createDefault(framework?: 'nextjs'): Promise<BridgeConfiguration>;
+    save(config: BridgeConfiguration, configPath?: string): Promise<void>;
+}
+
+interface FileOptions {
+    atomic?: boolean;
+    backup?: boolean;
+    encoding?: BufferEncoding;
+}
+declare class FileSystemManager {
+    writeFile(filePath: string, content: string, options?: FileOptions): Promise<void>;
+    readFile(filePath: string, encoding?: BufferEncoding): Promise<string>;
+    exists(filePath: string): Promise<boolean>;
+    getFileHash(filePath: string): Promise<string>;
+    removeDir(dirPath: string): Promise<void>;
+    findFiles(dir: string, pattern: RegExp, recursive?: boolean): Promise<string[]>;
+}
+
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+    timestamp?: boolean;
+    colors?: boolean;
+}
+declare class BridgeLogger {
+    options: Required<LoggerOptions>;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private formatMessage;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    success(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    spinner(message: string): {
+        succeed: (msg?: string) => void;
+        fail: (msg?: string) => void;
+        stop: () => void;
+    };
+}
+
+interface VersionInfo {
+    current: string;
+    latest: string;
+    isOutdated: boolean;
+    updateAvailable: boolean;
+}
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'unknown';
+declare class VersionChecker {
+    private logger;
+    private packageName;
+    private currentVersion;
+    private cache;
+    private readonly CACHE_DURATION;
+    constructor(packageName: string, currentVersion: string, logger?: BridgeLogger);
+    /**
+     * Check if a new version is available
+     */
+    checkForUpdates(): Promise<VersionInfo | null>;
+    /**
+     * Detect the package manager being used
+     */
+    detectPackageManager(): PackageManager;
+    /**
+     * Get the appropriate upgrade command for the detected package manager
+     */
+    getUpgradeCommand(versionInfo: VersionInfo): string;
+    /**
+     * Get a user-friendly update message
+     */
+    getUpdateMessage(versionInfo: VersionInfo): string;
+    /**
+     * Display update notification to user
+     */
+    displayUpdateNotification(versionInfo: VersionInfo, options?: {
+        showIfUpToDate?: boolean;
+        force?: boolean;
+        professional?: boolean;
+    }): void;
+    /**
+     * Fetch the latest version from npm registry
+     */
+    private fetchLatestVersion;
+    /**
+     * Compare two semantic versions
+     */
+    private isVersionOutdated;
+    /**
+     * Parse semantic version string into array of numbers
+     */
+    private parseVersion;
+    /**
+     * Get cached version info if available and not expired
+     */
+    private getCachedVersion;
+    /**
+     * Cache version info
+     */
+    private cacheVersion;
+    /**
+     * Clear version cache
+     */
+    clearCache(): void;
+    /**
+     * Get current version
+     */
+    getCurrentVersion(): string;
+    /**
+     * Get package name
+     */
+    getPackageName(): string;
+}
+/**
+ * Create a version checker instance for the Mulink library
+ */
+declare function createBridgeVersionChecker(logger?: BridgeLogger): VersionChecker;
+/**
+ * Check for updates and display notification
+ */
+declare function checkAndNotifyUpdates(options?: {
+    showIfUpToDate?: boolean;
+    force?: boolean;
+    professional?: boolean;
+    logger?: BridgeLogger;
+}): Promise<VersionInfo | null>;
+
+export { type ApiConfiguration as A, type BridgeConfiguration as B, ConfigurationLoader as C, type DevelopmentConfiguration as D, type EndpointMetadata as E, FileSystemManager as F, type GenerationContext as G, type HttpMethod as H, GenerationError as I, type ClientConfiguration as J, type RequestConfiguration as K, LogLevel as L, type ClientResponse as M, type StreamingResponse as N, OpenApiSchemaParser as O, type PluginConfiguration as P, type RequestBodyDefinition as R, type SchemaDefinition as S, VersionChecker as V, type GeneratedFile as a, BridgeCore as b, BridgeLogger as c, createBridgeVersionChecker as d, checkAndNotifyUpdates as e, type FrameworkConfiguration as f, type AuthConfiguration as g, type CacheConfiguration as h, type GenerationConfiguration as i, type OpenApiDocument as j, type ParsedApiSchema as k, type ApiEndpointDefinition as l, type ParameterDefinition as m, type ApiResponseDefinition as n, type SecuritySchemeDefinition as o, type ServerDefinition as p, type SchemaMetadata as q, type SecurityRequirement as r, type CacheStrategy as s, type RateLimit as t, type FileMetadata as u, type BridgePlugin as v, type VersionInfo as w, BridgeError as x, ValidationError as y, SchemaParseError as z };

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "mulink",
+  "version": "1.0.0",
+  "description": "Universal type-safe API integration library for modern web applications",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/lib/index.d.ts",
+      "import": "./dist/lib/index.js",
+      "require": "./dist/lib/index.cjs"
+    },
+    "./client": {
+      "types": "./dist/lib/client.d.ts",
+      "import": "./dist/lib/client.js",
+      "require": "./dist/lib/client.cjs"
+    },
+    "./cli": {
+      "types": "./dist/lib/cli.d.ts",
+      "import": "./dist/lib/cli.js",
+      "require": "./dist/lib/cli.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/lib/index.cjs",
+  "module": "./dist/lib/index.js",
+  "types": "./dist/lib/index.d.ts",
+  "bin": {
+    "mulink": "./dist/lib/cli.cjs"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:watch": "vitest --watch",
+    "lint": "eslint src/**/*.ts --fix",
+    "lint:check": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts",
+    "type-check": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "prepublish": "npm run build",
+    "prepublishOnly": "npm run test && npm run lint && npm run type-check",
+    "release": "npm run build && npm publish",
+    "analyze": "ANALYZE=true npm run build"
+  },
+  "keywords": [
+    "api",
+    "mulverse",
+    "Mohemed AlHabob",
+    "Obaidullah AlQurashi",
+    "mulink",
+    "typescript",
+    "codegen",
+    "openapi",
+    "rest",
+    "graphql",
+    "react",
+    "nextjs",
+    "vite",
+    "type-safety",
+    "developer-experience",
+    "code-generation",
+    "api-client"
+  ],
+  "author": "Mohemed Alhabob",
+  "license": "MUV",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mulverseco/mulink"
+  },
+  "bugs": {
+    "url": "https://github.com/mulverseco/mulink/issues"
+  },
+  "homepage": "https://mulverse.com/projects/libraries/mulink",
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "commander": "^11.1.0",
+    "lz-string": "^1.5.0",
+    "openapi-types": "^12.1.3",
+    "server-only": "^0.0.1",
+    "swagger2openapi": "^7.0.8",
+    "zod": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/eslint": "^9.6.1",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^20.10.0",
+    "@types/swagger2openapi": "^7.0.4",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "eslint": "^8.54.0",
+    "prettier": "^3.1.0",
+    "rimraf": "^5.0.10",
+    "tsup": "^8.5.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.0.0",
+    "next": ">=14.0.0 <17.0.0",
+    "react": ">=18.0.0",
+    "zod": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "next-auth": {
+      "optional": true
+    },
+    "next-safe-action": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}