@skroz/profile-api 1.0.19 → 1.0.21

package/dist/resolvers/createOauthResolver.d.ts

@@ -1,12 +1,28 @@
 import { ProfileAuthService } from '../services/ProfileAuthService';
 import { OAuthProvider } from '../oauth/OAuthProvider';
 import { ProfileContext } from '../types';
+type RedisClient = {
+    get(key: string): Promise<string | null>;
+    setex(key: string, ttl: number, value: string): Promise<any>;
+    del(key: string): Promise<any>;
+};
+/**
+ * Вызывается ботом при получении /start tgauth_<token>.
+ * Записывает telegramUserId в Redis, подтверждая авторизацию.
+ * Возвращает true если токен найден и подтверждён, false если истёк или не существует.
+ */
+export declare function confirmTelegramBotAuth(redis: RedisClient, token: string, telegramUserId: number | string): Promise<boolean>;
 export interface OauthResolverDependencies<TContext extends ProfileContext = ProfileContext> {
     authService: ProfileAuthService | ((ctx: TContext) => ProfileAuthService);
     userType: any;
     providers: Record<string, OAuthProvider>;
     telegramBotToken?: string;
+    /** Имя Telegram-бота (без @) для авторизации через бота (bot deep link) */
+    telegramBotName?: string;
+    /** Redis-клиент для авторизации через бота */
+    redis?: RedisClient;
     onUserCreated?: (user: any, ctx: TContext) => Promise<void>;
     onLogin?: (user: any, ctx: TContext) => Promise<void>;
 }
 export declare function createOauthResolver<TContext extends ProfileContext = ProfileContext>(deps: OauthResolverDependencies<TContext>): any;
+export {};

package/dist/resolvers/createOauthResolver.js

@@ -35,11 +35,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmTelegramBotAuth = confirmTelegramBotAuth;
 exports.createOauthResolver = createOauthResolver;
 const crypto_1 = __importDefault(require("crypto"));
 const nanoid_1 = require("nanoid");
 const type_graphql_1 = require("type-graphql");
 const OauthInput_1 = require("../dto/OauthInput");
+// Префикс Redis-ключей намеренно длинный, чтобы исключить коллизии с любыми
+// другими ключами в том же Redis-инстансе.
+const TELEGRAM_BOT_AUTH_REDIS_PREFIX = 'skroz:profile:tgbotauth';
+const TELEGRAM_BOT_AUTH_TOKEN_TTL_SECONDS = 300; // 5 минут
+/**
+ * Вызывается ботом при получении /start tgauth_<token>.
+ * Записывает telegramUserId в Redis, подтверждая авторизацию.
+ * Возвращает true если токен найден и подтверждён, false если истёк или не существует.
+ */
+function confirmTelegramBotAuth(redis, token, telegramUserId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const redisKey = `${TELEGRAM_BOT_AUTH_REDIS_PREFIX}:${token}`;
+        const val = yield redis.get(redisKey);
+        if (val !== 'pending')
+            return false;
+        yield redis.setex(redisKey, TELEGRAM_BOT_AUTH_TOKEN_TTL_SECONDS, String(telegramUserId));
+        return true;
+    });
+}
+let TelegramBotAuthLinkPayload = class TelegramBotAuthLinkPayload {
+};
+__decorate([
+    (0, type_graphql_1.Field)(),
+    __metadata("design:type", String)
+], TelegramBotAuthLinkPayload.prototype, "token", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(),
+    __metadata("design:type", String)
+], TelegramBotAuthLinkPayload.prototype, "url", void 0);
+TelegramBotAuthLinkPayload = __decorate([
+    (0, type_graphql_1.ObjectType)()
+], TelegramBotAuthLinkPayload);
+let TelegramBotAuthConfirmResult = class TelegramBotAuthConfirmResult {
+};
+__decorate([
+    (0, type_graphql_1.Field)(),
+    __metadata("design:type", Boolean)
+], TelegramBotAuthConfirmResult.prototype, "confirmed", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(),
+    __metadata("design:type", Boolean)
+], TelegramBotAuthConfirmResult.prototype, "expired", void 0);
+TelegramBotAuthConfirmResult = __decorate([
+    (0, type_graphql_1.ObjectType)()
+], TelegramBotAuthConfirmResult);
 function validateTelegramHash(data, botToken) {
     const { hash } = data, rest = __rest(data, ["hash"]);
     const sorted = Object.keys(rest)
@@ -55,7 +101,7 @@ function validateTelegramHash(data, botToken) {
     return hmac === hash;
 }
 function createOauthResolver(deps) {
-    const { authService, userType, providers, telegramBotToken, onUserCreated, onLogin, } = deps;
+    const { authService, userType, providers, telegramBotToken, telegramBotName, redis, onUserCreated, onLogin, } = deps;
     const getAuthService = (ctx) => {
         if (typeof authService === 'function')
             return authService(ctx);
@@ -136,6 +182,50 @@ function createOauthResolver(deps) {
                 return user;
             });
         }
+        generateTelegramAuthToken() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!telegramBotName)
+                    throw new Error('telegramBotName is not configured');
+                if (!redis)
+                    throw new Error('redis is not configured');
+                const token = (0, nanoid_1.nanoid)(32);
+                const redisKey = `${TELEGRAM_BOT_AUTH_REDIS_PREFIX}:${token}`;
+                yield redis.setex(redisKey, TELEGRAM_BOT_AUTH_TOKEN_TTL_SECONDS, 'pending');
+                const url = `https://t.me/${telegramBotName}?start=tgauth_${token}`;
+                return { token, url };
+            });
+        }
+        confirmTelegramAuthToken(token, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!redis)
+                    throw new Error('redis is not configured');
+                const redisKey = `${TELEGRAM_BOT_AUTH_REDIS_PREFIX}:${token}`;
+                const val = yield redis.get(redisKey);
+                if (!val) {
+                    return { confirmed: false, expired: true };
+                }
+                if (val === 'pending') {
+                    return { confirmed: false, expired: false };
+                }
+                const userId = parseInt(val, 10);
+                if (Number.isNaN(userId)) {
+                    return { confirmed: false, expired: true };
+                }
+                const service = getAuthService(ctx);
+                const user = yield service.db.findUserById(userId);
+                if (!user) {
+                    return { confirmed: false, expired: true };
+                }
+                const userAgent = decodeURI(ctx.req.get('user-agent') || '');
+                yield ctx.req.session.create({
+                    userId: user.id,
+                    ip: ctx.req.ip,
+                    userAgent: userAgent.slice(0, 500),
+                });
+                yield redis.del(redisKey);
+                return { confirmed: true, expired: false };
+            });
+        }
     };
     __decorate([
         (0, type_graphql_1.Mutation)(() => userType),
@@ -145,6 +235,20 @@ function createOauthResolver(deps) {
         __metadata("design:paramtypes", [OauthInput_1.OauthLoginInput, Object]),
         __metadata("design:returntype", Promise)
     ], OauthResolver.prototype, "oauthLogin", null);
+    __decorate([
+        (0, type_graphql_1.Mutation)(() => TelegramBotAuthLinkPayload),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], OauthResolver.prototype, "generateTelegramAuthToken", null);
+    __decorate([
+        (0, type_graphql_1.Mutation)(() => TelegramBotAuthConfirmResult),
+        __param(0, (0, type_graphql_1.Arg)('token')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, Object]),
+        __metadata("design:returntype", Promise)
+    ], OauthResolver.prototype, "confirmTelegramAuthToken", null);
     OauthResolver = __decorate([
         (0, type_graphql_1.Resolver)(() => userType)
     ], OauthResolver);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skroz/profile-api",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "license": "MIT",
   "repository": "git@gitlab.com:skroz/libs/utils.git",
   "main": "dist/index.js",
@@ -44,5 +44,5 @@
     "type-graphql": "^1.1.1",
     "typeorm": "^0.2.45"
   },
-  "gitHead": "ad9d511d8f623ad1a5d3a6a83e016c4b12d4f211"
+  "gitHead": "4d48bd69998725da84ce966a6ab383fb5eb208cc"
 }

package/src/resolvers/createOauthResolver.ts

@@ -1,11 +1,57 @@
 import crypto from 'crypto';
 import { nanoid } from 'nanoid';
-import { Arg, Ctx, Mutation, Resolver } from 'type-graphql';
+import { Arg, Ctx, Mutation, ObjectType, Field, Resolver } from 'type-graphql';
 import { ProfileAuthService } from '../services/ProfileAuthService';
 import { OAuthProvider } from '../oauth/OAuthProvider';
 import { OauthLoginInput, TelegramAuthData } from '../dto/OauthInput';
 import { ProfileContext } from '../types';
 
+type RedisClient = {
+  get(key: string): Promise<string | null>;
+  setex(key: string, ttl: number, value: string): Promise<any>;
+  del(key: string): Promise<any>;
+};
+
+// Префикс Redis-ключей намеренно длинный, чтобы исключить коллизии с любыми
+// другими ключами в том же Redis-инстансе.
+const TELEGRAM_BOT_AUTH_REDIS_PREFIX = 'skroz:profile:tgbotauth';
+const TELEGRAM_BOT_AUTH_TOKEN_TTL_SECONDS = 300; // 5 минут
+
+/**
+ * Вызывается ботом при получении /start tgauth_<token>.
+ * Записывает telegramUserId в Redis, подтверждая авторизацию.
+ * Возвращает true если токен найден и подтверждён, false если истёк или не существует.
+ */
+export async function confirmTelegramBotAuth(
+  redis: RedisClient,
+  token: string,
+  telegramUserId: number | string
+): Promise<boolean> {
+  const redisKey = `${TELEGRAM_BOT_AUTH_REDIS_PREFIX}:${token}`;
+  const val = await redis.get(redisKey);
+  if (val !== 'pending') return false;
+  await redis.setex(redisKey, TELEGRAM_BOT_AUTH_TOKEN_TTL_SECONDS, String(telegramUserId));
+  return true;
+}
+
+@ObjectType()
+class TelegramBotAuthLinkPayload {
+  @Field()
+  token!: string;
+
+  @Field()
+  url!: string;
+}
+
+@ObjectType()
+class TelegramBotAuthConfirmResult {
+  @Field()
+  confirmed!: boolean;
+
+  @Field()
+  expired!: boolean;
+}
+
 export interface OauthResolverDependencies<
   TContext extends ProfileContext = ProfileContext
 > {
@@ -13,6 +59,10 @@ export interface OauthResolverDependencies<
   userType: any;
   providers: Record<string, OAuthProvider>;
   telegramBotToken?: string;
+  /** Имя Telegram-бота (без @) для авторизации через бота (bot deep link) */
+  telegramBotName?: string;
+  /** Redis-клиент для авторизации через бота */
+  redis?: RedisClient;
   onUserCreated?: (user: any, ctx: TContext) => Promise<void>;
   onLogin?: (user: any, ctx: TContext) => Promise<void>;
 }
@@ -43,6 +93,8 @@ export function createOauthResolver<
     userType,
     providers,
     telegramBotToken,
+    telegramBotName,
+    redis,
     onUserCreated,
     onLogin,
   } = deps;
@@ -137,6 +189,58 @@ export function createOauthResolver<
 
       return user;
     }
+
+    @Mutation(() => TelegramBotAuthLinkPayload)
+    async generateTelegramAuthToken(): Promise<TelegramBotAuthLinkPayload> {
+      if (!telegramBotName) throw new Error('telegramBotName is not configured');
+      if (!redis) throw new Error('redis is not configured');
+
+      const token = nanoid(32);
+      const redisKey = `${TELEGRAM_BOT_AUTH_REDIS_PREFIX}:${token}`;
+      await redis.setex(redisKey, TELEGRAM_BOT_AUTH_TOKEN_TTL_SECONDS, 'pending');
+      const url = `https://t.me/${telegramBotName}?start=tgauth_${token}`;
+      return { token, url };
+    }
+
+    @Mutation(() => TelegramBotAuthConfirmResult)
+    async confirmTelegramAuthToken(
+      @Arg('token') token: string,
+      @Ctx() ctx: TContext
+    ): Promise<TelegramBotAuthConfirmResult> {
+      if (!redis) throw new Error('redis is not configured');
+
+      const redisKey = `${TELEGRAM_BOT_AUTH_REDIS_PREFIX}:${token}`;
+      const val = await redis.get(redisKey);
+
+      if (!val) {
+        return { confirmed: false, expired: true };
+      }
+
+      if (val === 'pending') {
+        return { confirmed: false, expired: false };
+      }
+
+      const userId = parseInt(val, 10);
+      if (Number.isNaN(userId)) {
+        return { confirmed: false, expired: true };
+      }
+
+      const service = getAuthService(ctx);
+      const user = await service.db.findUserById(userId);
+      if (!user) {
+        return { confirmed: false, expired: true };
+      }
+
+      const userAgent = decodeURI(ctx.req.get('user-agent') || '');
+      await ctx.req.session.create({
+        userId: user.id,
+        ip: ctx.req.ip,
+        userAgent: userAgent.slice(0, 500),
+      });
+      await redis.del(redisKey);
+
+      return { confirmed: true, expired: false };
+    }
   }
 
   return OauthResolver;