@morojs/moro 1.0.3 → 1.2.0

package/dist/types/auth.d.ts

@@ -0,0 +1,367 @@
+export interface AuthProvider {
+    id: string;
+    name: string;
+    type: 'oauth' | 'oidc' | 'credentials' | 'email';
+    authorization?: string | {
+        url: string;
+        params?: Record<string, any>;
+    };
+    token?: string | {
+        url: string;
+        params?: Record<string, any>;
+    };
+    userinfo?: string | {
+        url: string;
+        params?: Record<string, any>;
+    };
+    issuer?: string;
+    wellKnown?: string;
+    clientId?: string;
+    clientSecret?: string;
+    scope?: string;
+    claims?: Record<string, any>;
+    profile?: (profile: any, tokens: any) => Promise<any> | any;
+    authorization_params?: Record<string, any>;
+    token_endpoint_auth_method?: 'client_secret_post' | 'client_secret_basic';
+    [key: string]: any;
+}
+export interface OAuthProvider extends AuthProvider {
+    type: 'oauth';
+    authorization: string | {
+        url: string;
+        params?: Record<string, any>;
+    };
+    token: string | {
+        url: string;
+        params?: Record<string, any>;
+    };
+    userinfo?: string | {
+        url: string;
+        params?: Record<string, any>;
+    };
+}
+export interface OIDCProvider extends AuthProvider {
+    type: 'oidc';
+    issuer: string;
+    wellKnown?: string;
+}
+export interface CredentialsProvider extends AuthProvider {
+    type: 'credentials';
+    credentials: Record<string, {
+        label?: string;
+        type?: string;
+        placeholder?: string;
+        [key: string]: any;
+    }>;
+    authorize: (credentials: Record<string, any>, req: any) => Promise<any> | any;
+}
+export interface EmailProvider extends AuthProvider {
+    type: 'email';
+    server: string | {
+        host: string;
+        port: number;
+        auth: {
+            user: string;
+            pass: string;
+        };
+        secure?: boolean;
+        tls?: any;
+    };
+    from: string;
+    sendVerificationRequest?: (params: {
+        identifier: string;
+        url: string;
+        expires: Date;
+        provider: EmailProvider;
+        token: string;
+        theme: any;
+        request: any;
+    }) => Promise<void>;
+}
+export interface AuthUser {
+    id: string;
+    name?: string | null;
+    email?: string | null;
+    image?: string | null;
+    emailVerified?: Date | null;
+    [key: string]: any;
+}
+export interface AuthAccount {
+    userId: string;
+    type: 'oauth' | 'oidc' | 'email' | 'credentials';
+    provider: string;
+    providerAccountId: string;
+    access_token?: string;
+    expires_at?: number;
+    id_token?: string;
+    refresh_token?: string;
+    refresh_token_expires_in?: number;
+    scope?: string;
+    token_type?: string;
+    session_state?: string;
+    [key: string]: any;
+}
+export interface AuthSession {
+    sessionToken: string;
+    userId: string;
+    expires: Date;
+    user: AuthUser;
+    [key: string]: any;
+}
+export interface VerificationToken {
+    identifier: string;
+    token: string;
+    expires: Date;
+}
+export interface AuthJWT {
+    name?: string | null;
+    email?: string | null;
+    picture?: string | null;
+    sub?: string;
+    iat?: number;
+    exp?: number;
+    jti?: string;
+    [key: string]: any;
+}
+export interface AuthCallbacks {
+    signIn?: (params: {
+        user: AuthUser;
+        account: AuthAccount | null;
+        profile?: any;
+        email?: {
+            verificationRequest?: boolean;
+        };
+        credentials?: Record<string, any>;
+    }) => Awaitable<boolean | string>;
+    redirect?: (params: {
+        url: string;
+        baseUrl: string;
+    }) => Awaitable<string>;
+    session?: (params: {
+        session: AuthSession;
+        user: AuthUser;
+        token: AuthJWT;
+    }) => Awaitable<AuthSession>;
+    jwt?: (params: {
+        token: AuthJWT;
+        user?: AuthUser;
+        account?: AuthAccount;
+        profile?: any;
+        trigger?: 'signIn' | 'signUp' | 'update';
+        isNewUser?: boolean;
+        session?: any;
+    }) => Awaitable<AuthJWT>;
+}
+export interface AuthPages {
+    signIn?: string;
+    signOut?: string;
+    error?: string;
+    verifyRequest?: string;
+    newUser?: string;
+}
+export interface AuthEvents {
+    signIn?: (message: {
+        user: AuthUser;
+        account: AuthAccount | null;
+        profile?: any;
+        isNewUser?: boolean;
+    }) => Awaitable<void>;
+    signOut?: (message: {
+        session: AuthSession;
+        token: AuthJWT;
+    }) => Awaitable<void>;
+    createUser?: (message: {
+        user: AuthUser;
+    }) => Awaitable<void>;
+    updateUser?: (message: {
+        user: AuthUser;
+    }) => Awaitable<void>;
+    linkAccount?: (message: {
+        user: AuthUser;
+        account: AuthAccount;
+        profile: any;
+    }) => Awaitable<void>;
+    session?: (message: {
+        session: AuthSession;
+        token: AuthJWT;
+    }) => Awaitable<void>;
+}
+export interface AuthCookies {
+    sessionToken: {
+        name: string;
+        options?: CookieOptions;
+    };
+    callbackUrl: {
+        name: string;
+        options?: CookieOptions;
+    };
+    csrfToken: {
+        name: string;
+        options?: CookieOptions;
+    };
+    pkceCodeVerifier: {
+        name: string;
+        options?: CookieOptions;
+    };
+    state: {
+        name: string;
+        options?: CookieOptions;
+    };
+    nonce: {
+        name: string;
+        options?: CookieOptions;
+    };
+}
+export interface CookieOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'strict' | 'lax' | 'none';
+    secure?: boolean;
+}
+export interface AuthTheme {
+    colorScheme?: 'light' | 'dark' | 'auto';
+    logo?: string;
+    brandColor?: string;
+    buttonText?: string;
+    [key: string]: any;
+}
+export interface AuthLogger {
+    error: (code: string, metadata?: any) => void;
+    warn: (code: string) => void;
+    debug: (code: string, metadata?: any) => void;
+}
+export interface AuthAdapter {
+    createUser?: (user: Omit<AuthUser, 'id'>) => Awaitable<AuthUser>;
+    getUser?: (id: string) => Awaitable<AuthUser | null>;
+    getUserByEmail?: (email: string) => Awaitable<AuthUser | null>;
+    getUserByAccount?: (providerAccountId: Pick<AuthAccount, 'provider' | 'providerAccountId'>) => Awaitable<AuthUser | null>;
+    updateUser?: (user: Partial<AuthUser> & Pick<AuthUser, 'id'>) => Awaitable<AuthUser>;
+    deleteUser?: (userId: string) => Awaitable<void>;
+    linkAccount?: (account: AuthAccount) => Awaitable<void>;
+    unlinkAccount?: (providerAccountId: Pick<AuthAccount, 'provider' | 'providerAccountId'>) => Awaitable<void>;
+    createSession?: (session: {
+        sessionToken: string;
+        userId: string;
+        expires: Date;
+    }) => Awaitable<AuthSession>;
+    getSessionAndUser?: (sessionToken: string) => Awaitable<{
+        session: AuthSession;
+        user: AuthUser;
+    } | null>;
+    updateSession?: (session: Partial<AuthSession> & Pick<AuthSession, 'sessionToken'>) => Awaitable<AuthSession | null | undefined>;
+    deleteSession?: (sessionToken: string) => Awaitable<void>;
+    createVerificationToken?: (verificationToken: VerificationToken) => Awaitable<VerificationToken | null | undefined>;
+    useVerificationToken?: (params: {
+        identifier: string;
+        token: string;
+    }) => Awaitable<VerificationToken | null>;
+}
+export interface AuthOptions {
+    providers: AuthProvider[];
+    secret?: string;
+    session?: {
+        strategy?: 'jwt' | 'database';
+        maxAge?: number;
+        updateAge?: number;
+        generateSessionToken?: () => string;
+    };
+    jwt?: {
+        secret?: string;
+        maxAge?: number;
+        encode?: (params: {
+            token?: AuthJWT;
+            secret: string;
+            maxAge?: number;
+        }) => Awaitable<string>;
+        decode?: (params: {
+            token?: string;
+            secret: string;
+        }) => Awaitable<AuthJWT | null>;
+    };
+    callbacks?: AuthCallbacks;
+    events?: AuthEvents;
+    adapter?: AuthAdapter;
+    pages?: AuthPages;
+    cookies?: Partial<AuthCookies>;
+    theme?: AuthTheme;
+    logger?: AuthLogger;
+    debug?: boolean;
+    basePath?: string;
+    useSecureCookies?: boolean;
+    trustHost?: boolean;
+    skipCSRFCheck?: string[];
+    experimental?: {
+        enableWebAuthn?: boolean;
+        [key: string]: any;
+    };
+}
+export interface AuthRequest {
+    user?: AuthUser;
+    session?: AuthSession;
+    token?: string;
+    isAuthenticated: boolean;
+    signIn: (provider?: string, options?: {
+        callbackUrl?: string;
+        redirect?: boolean;
+        [key: string]: any;
+    }) => Promise<any>;
+    signOut: (options?: {
+        callbackUrl?: string;
+        redirect?: boolean;
+    }) => Promise<any>;
+    getSession: () => Promise<AuthSession | null>;
+    getToken: () => Promise<AuthJWT | null>;
+    getCsrfToken: () => Promise<string>;
+    getProviders: () => Promise<Record<string, AuthProvider>>;
+}
+export interface AuthResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: any;
+    redirect?: string;
+}
+export interface AuthConfig extends AuthOptions {
+    basePath: string;
+    baseUrl: string;
+    providers: AuthProvider[];
+    skipCSRFCheck: string[];
+    useSecureCookies: boolean;
+}
+export type Awaitable<T> = T | Promise<T>;
+export type ProviderType = 'oauth' | 'oidc' | 'credentials' | 'email';
+export type SignInOptions = {
+    callbackUrl?: string;
+    redirect?: boolean;
+    [key: string]: any;
+};
+export type SignOutOptions = {
+    callbackUrl?: string;
+    redirect?: boolean;
+};
+export interface AuthError extends Error {
+    type: string;
+    code?: string;
+}
+export declare class SignInError extends Error implements AuthError {
+    type: string;
+    code?: string;
+    constructor(message: string, code?: string);
+}
+export declare class CallbackError extends Error implements AuthError {
+    type: string;
+    code?: string;
+    constructor(message: string, code?: string);
+}
+export declare class SessionError extends Error implements AuthError {
+    type: string;
+    code?: string;
+    constructor(message: string, code?: string);
+}
+export type { AuthProvider as Provider };
+export type { AuthUser as User };
+export type { AuthSession as Session };
+export type { AuthAccount as Account };
+export type { AuthJWT as JWT };

package/dist/types/auth.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionError = exports.CallbackError = exports.SignInError = void 0;
+class SignInError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.type = 'SignInError';
+        this.code = code;
+    }
+}
+exports.SignInError = SignInError;
+class CallbackError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.type = 'CallbackError';
+        this.code = code;
+    }
+}
+exports.CallbackError = CallbackError;
+class SessionError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.type = 'SessionError';
+        this.code = code;
+    }
+}
+exports.SessionError = SessionError;
+//# sourceMappingURL=auth.js.map

package/dist/types/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/types/auth.ts"],"names":[],"mappings":";;;AAoZA,MAAa,WAAY,SAAQ,KAAK;IAIpC,YAAY,OAAe,EAAE,IAAa;QACxC,KAAK,CAAC,OAAO,CAAC,CAAC;QAJjB,SAAI,GAAG,aAAa,CAAC;QAKnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AARD,kCAQC;AAED,MAAa,aAAc,SAAQ,KAAK;IAItC,YAAY,OAAe,EAAE,IAAa;QACxC,KAAK,CAAC,OAAO,CAAC,CAAC;QAJjB,SAAI,GAAG,eAAe,CAAC;QAKrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AARD,sCAQC;AAED,MAAa,YAAa,SAAQ,KAAK;IAIrC,YAAY,OAAe,EAAE,IAAa;QACxC,KAAK,CAAC,OAAO,CAAC,CAAC;QAJjB,SAAI,GAAG,cAAc,CAAC;QAKpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AARD,oCAQC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morojs/moro",
-  "version": "1.0.3",
-  "description": "High-performance Node.js framework with intelligent routing, automatic middleware ordering, type-safe Zod validation, and functional architecture",
+  "version": "1.2.0",
+  "description": "High-performance Node.js framework with intelligent routing, automatic middleware ordering, enterprise authentication (Auth.js), type-safe Zod validation, and functional architecture",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -75,6 +75,7 @@
     "zod": "^4.1.5"
   },
   "peerDependencies": {
+    "@auth/core": "^0.37.3",
     "better-sqlite3": "^12.2.0",
     "drizzle-orm": "^0.44.5",
     "ioredis": "^5.7.0",
@@ -85,6 +86,9 @@
     "ts-node": "^10.9.1"
   },
   "peerDependenciesMeta": {
+    "@auth/core": {
+      "optional": true
+    },
     "mysql2": {
       "optional": true
     },