@ministerjs/auth 2.0.0 → 2.0.2

package/package.json

@@ -1,24 +1,29 @@
 {
   "name": "@ministerjs/auth",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
   "files": [
-    "dist/*"
+    "dist/*",
+    "types/*"
   ],
+  "types": "./types",
   "exports": {
+    "./types": {
+      "types": "./types/index.d.ts"
+    },
     "./vue": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "types": "./dist/vue.d.ts",
+      "import": "./dist/vue.mjs",
+      "require": "./dist/vue.js"
     },
     "./nestjs": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "types": "./dist/nestjs.d.ts",
+      "import": "./dist/nestjs.mjs",
+      "require": "./dist/nestjs.js"
     }
   },
   "peerDependencies": {
@@ -60,6 +65,7 @@
     "dev": "tsup --watch",
     "lint": "eslint ./src --fix --config ../../eslint.config.mjs",
     "test": "vitest run --root ../../ --project @ministerjs/auth",
-    "build": "pnpm lint && pnpm test && tsup"
+    "build:types": "rimraf types && tsc --project tsconfig.build.json && cpx \"src/**/*.d.ts\" types/",
+    "build": "pnpm lint && pnpm test && pnpm build:types && tsup"
   }
 }

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./vue";
+export * from "./nestjs";

package/types/nestjs/AuthController.d.ts

@@ -0,0 +1,10 @@
+import type { Request, Response } from "express";
+import type { AuthDriver, AuthPayload, AuthResponse, LogoutResponse } from "./types";
+declare class AuthController<User extends Record<string, any> = Record<string, any>> {
+    private readonly driver;
+    constructor(driver: AuthDriver<User>);
+    login(body: AuthPayload, request: Request, response: Response): Promise<AuthResponse<User>>;
+    checkIn(request: Request, response: Response): Promise<AuthResponse<User>>;
+    logout(request: Request, response: Response): Promise<LogoutResponse>;
+}
+export { AuthController };

package/types/nestjs/AuthModule.d.ts

@@ -0,0 +1,32 @@
+import { DynamicModule, Type } from "@nestjs/common";
+import type { AuthDriver } from "./types";
+type DriverProvider<User> = AuthDriver<User> | {
+    useValue: AuthDriver<User>;
+} | {
+    useClass: Type<AuthDriver<User>>;
+} | {
+    useFactory: (...args: any[]) => Promise<AuthDriver<User>> | AuthDriver<User>;
+    inject?: any[];
+} | Type<AuthDriver<User>>;
+interface AuthModuleOptions<User = any> {
+    /**
+     * Provider que implementa a interface AuthDriver.
+     * Aceita instância direta, classe Nest provider ou useFactory.
+     */
+    driver: DriverProvider<User>;
+}
+interface AuthModuleAsyncOptions<User = any> {
+    imports?: any[];
+    /**
+     * Factory que devolve uma instância de AuthDriver.
+     */
+    useFactory: (...args: any[]) => Promise<AuthDriver<User>> | AuthDriver<User>;
+    inject?: any[];
+}
+declare class AuthModule {
+    static register<User = any>(options: AuthModuleOptions<User>): DynamicModule;
+    static registerAsync<User = any>(options: AuthModuleAsyncOptions<User>): DynamicModule;
+    private static normalizeDriverProvider;
+}
+export type { AuthModuleOptions, AuthModuleAsyncOptions, DriverProvider };
+export { AuthModule };

package/types/nestjs/JwtPrismaCookieAuthDriver.d.ts

@@ -0,0 +1,65 @@
+import type { CookieOptions, Request, Response } from "express";
+import { type SignOptions } from "jsonwebtoken";
+import type { AuthDriver, AuthPayload } from "./types";
+type PrismaClientLike = Record<string, any>;
+interface JwtPrismaDriverOptions {
+    prisma: PrismaClientLike;
+    /**
+     * Nome do model Prisma (ex.: "user").
+     */
+    modelName: string;
+    /**
+     * Campo usado como identificador de login (ex.: "email").
+     */
+    identifierField?: string;
+    /**
+     * Campo usado como senha (hash) no banco.
+     */
+    passwordField?: string;
+    /**
+     * Campo de ID primário (usado no payload do token).
+     */
+    idField?: string;
+    /**
+     * Segredo para assinar/verificar JWT.
+     */
+    jwtSecret: string;
+    /**
+     * Tempo de expiração (aceita formato jsonwebtoken, ex.: "7d").
+     */
+    jwtExpiresIn?: SignOptions["expiresIn"];
+    /**
+     * Nome do cookie que armazena o token.
+     */
+    cookieName?: string;
+    /**
+     * Opções do cookie (secure, sameSite etc).
+     */
+    cookieOptions?: Partial<CookieOptions>;
+    /**
+     * Função de comparação de senha (p.ex. bcrypt.compare).
+     */
+    comparePassword?: (provided: string, stored: unknown) => Promise<boolean> | boolean;
+    /**
+     * Permite alterar a shape do usuário retornado.
+     */
+    transformUser?: <T extends Record<string, any>>(user: T) => any;
+}
+declare class JwtPrismaCookieAuthDriver<User extends Record<string, any>> implements AuthDriver<User> {
+    private readonly prismaModel;
+    private readonly identifierField;
+    private readonly passwordField;
+    private readonly idField;
+    private readonly jwtSecret;
+    private readonly jwtExpiresIn;
+    private readonly cookieName;
+    private readonly cookieOptions;
+    private readonly comparePassword;
+    private readonly transformUser;
+    constructor(options: JwtPrismaDriverOptions);
+    login(payload: AuthPayload, _req: Request, res: Response): Promise<User>;
+    checkIn(req: Request, res: Response): Promise<User | null>;
+    logout(_req: Request, res: Response): Promise<void>;
+}
+export type { JwtPrismaDriverOptions };
+export { JwtPrismaCookieAuthDriver };

package/types/nestjs/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./token";
+export * from "./AuthController";
+export * from "./AuthModule";
+export * from "./JwtPrismaCookieAuthDriver";

package/types/nestjs/token.d.ts

@@ -0,0 +1,2 @@
+declare const AUTH_DRIVER: unique symbol;
+export { AUTH_DRIVER };

package/types/nestjs/types.d.ts

@@ -0,0 +1,24 @@
+import type { Request, Response } from "express";
+export type AuthPayload = Record<string, any>;
+export interface AuthResponse<User> {
+    message: string;
+    data: User;
+}
+export interface LogoutResponse {
+    message: string;
+}
+export interface AuthDriver<User = any> {
+    /**
+     * Deve validar o payload recebido e retornar o usuário autenticado.
+     */
+    login(payload: AuthPayload, request: Request, response: Response): Promise<User> | User;
+    /**
+     * Deve recuperar o usuário a partir do contexto (cookies, headers, sessão, etc.).
+     * Retorne `null` ou `undefined` quando não houver sessão ativa.
+     */
+    checkIn(request: Request, response: Response): Promise<User | null | undefined> | User | null | undefined;
+    /**
+     * Deve encerrar a sessão/tokens do usuário.
+     */
+    logout(request: Request, response: Response): Promise<void> | void;
+}

package/types/vue/VueAuth.d.ts

@@ -0,0 +1,32 @@
+import { Ref } from "vue";
+import type { Fetch, FetchOptions, FetchResponse } from "@ministerjs/resource";
+interface Options<User extends Record<string, any>> {
+    fetch: Fetch;
+    mapUser?: (user: User) => User;
+    routes?: {
+        signUp?: string;
+        login?: string;
+        checkIn?: string;
+        logout?: string;
+    };
+    afterLogout: () => void | Promise<void>;
+    afterCheckIn: (result: boolean) => void | Promise<void>;
+}
+declare class Auth<User extends Record<string, any>> {
+    user: Ref<Partial<User> | null>;
+    on: Ref<boolean, boolean>;
+    loading: Ref<boolean, boolean>;
+    checkedIn: Ref<boolean, boolean>;
+    private fetch;
+    private mapUser;
+    private afterLogout;
+    private afterCheckIn;
+    private routes;
+    constructor({ fetch, mapUser, routes, afterLogout, afterCheckIn, }: Options<User>);
+    login(payload: Record<string, any>): Promise<void>;
+    checkIn(): Promise<void>;
+    logout(): Promise<void>;
+    private setUser;
+}
+export type { Fetch, FetchOptions, FetchResponse };
+export { Auth };

package/types/vue/index.d.ts

@@ -0,0 +1 @@
+export * from "./VueAuth";