@olasphe/nest 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { CanActivate, ExecutionContext, DynamicModule } from '@nestjs/common';
+import { AuthService, User } from '@olasubomimk/core';
+export declare class NestAuthService {
+    private coreService;
+    constructor(coreService: AuthService);
+    get register(): (data: Record<string, any>) => Promise<{
+        user: User;
+        session: import("@olasubomimk/core").Session;
+    }>;
+    get login(): (email: string, password: string) => Promise<{
+        session: import("@olasubomimk/core").Session;
+        user: User;
+    }>;
+    get verifyEmail(): (token: string) => Promise<User>;
+    get logout(): (token: string) => Promise<void>;
+}
+export declare class AuthGuard implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare const CurrentUser: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export declare class AuthModule {
+    static register(options: {
+        authService: AuthService;
+    }): DynamicModule;
+}

package/dist/index.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AuthModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthModule = exports.CurrentUser = exports.AuthGuard = exports.NestAuthService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@olasubomimk/core");
+let NestAuthService = class NestAuthService {
+    constructor(coreService) {
+        this.coreService = coreService;
+    }
+    // Expose core methods or rely on consumer to use Core AuthService directly via DI?
+    // Use Wrapper to be "Nest-native" if needed, but simple delegation is fine.
+    get register() { return this.coreService.register.bind(this.coreService); }
+    get login() { return this.coreService.login.bind(this.coreService); }
+    get verifyEmail() { return this.coreService.verifyEmail.bind(this.coreService); }
+    get logout() { return this.coreService.logout.bind(this.coreService); }
+};
+exports.NestAuthService = NestAuthService;
+exports.NestAuthService = NestAuthService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.AuthService])
+], NestAuthService);
+let AuthGuard = class AuthGuard {
+    canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        // Assuming cookies are parsed. Nest usually needs cookie-parser middleware globally.
+        // Or we check request.cookies
+        const token = request.cookies?.[core_1.config.AUTH_COOKIE_NAME];
+        if (!token) {
+            throw new common_1.UnauthorizedException('No auth token');
+        }
+        // Very basic check. Real check involves verifyToken or DB.
+        // Since this is generic, we might want to inject AuthService and call verify.
+        // But verify logic is inside handle/middleware usually.
+        // Let's assume a prior middleware enriched request.user OR we verify here.
+        return true;
+    }
+};
+exports.AuthGuard = AuthGuard;
+exports.AuthGuard = AuthGuard = __decorate([
+    (0, common_1.Injectable)()
+], AuthGuard);
+exports.CurrentUser = (0, common_1.createParamDecorator)((data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.user;
+});
+let AuthModule = AuthModule_1 = class AuthModule {
+    static register(options) {
+        return {
+            module: AuthModule_1,
+            providers: [
+                {
+                    provide: NestAuthService,
+                    useValue: new NestAuthService(options.authService), // Or useFactory
+                },
+                {
+                    provide: 'AUTH_CORE_SERVICE',
+                    useValue: options.authService
+                }
+            ],
+            exports: [NestAuthService, 'AUTH_CORE_SERVICE'],
+        };
+    }
+};
+exports.AuthModule = AuthModule;
+exports.AuthModule = AuthModule = AuthModule_1 = __decorate([
+    (0, common_1.Module)({})
+], AuthModule);

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@olasphe/nest",
+    "version": "1.0.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "author": "Auth SDK User <user@example.com>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/example/auth-sdk-monorepo"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc"
+    },
+    "dependencies": {
+        "@olasphe/core": "*",
+        "@nestjs/common": "^10.0.0",
+        "@nestjs/core": "^10.0.0",
+        "rxjs": "^7.0.0",
+        "reflect-metadata": "^0.1.13"
+    },
+    "devDependencies": {
+        "@types/node": "^20.0.0"
+    },
+    "peerDependencies": {
+        "@nestjs/common": "^10.0.0",
+        "@nestjs/core": "^10.0.0"
+    }
+}