@akanjs/nest 0.0.54 → 0.0.56

package/src/sso.mjs

@@ -0,0 +1,155 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { Injectable } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import * as appleSignin from "apple-signin";
+import * as jwt from "jsonwebtoken";
+import { Strategy as AppleStrategy } from "passport-apple";
+import { Strategy as FacebookStrategy } from "passport-facebook";
+import { Strategy as GithubStrategy } from "passport-github";
+import { Strategy as GoogleStrategy } from "passport-google-oauth20";
+import { Strategy as KakaoStrategy } from "passport-kakao";
+import { Strategy as NaverStrategy } from "passport-naver";
+const getSsoProviders = (host, ssoOptions) => {
+  const origin = host === "localhost" ? "http://localhost:8080/backend" : `https://${host}/backend`;
+  const providers = [];
+  if (ssoOptions.kakao) {
+    let KakaoOauthStrategy = class extends PassportStrategy(KakaoStrategy, "kakao") {
+      constructor() {
+        super({
+          ...ssoOptions.kakao,
+          callbackURL: `${origin}/user/kakao/callback`,
+          scope: ["account_email", "profile_nickname"]
+        });
+      }
+      validate(jwt2, refreshToken, profile) {
+        return {
+          name: profile.displayName,
+          email: profile._json.kakao_account.email,
+          password: profile.id
+        };
+      }
+    };
+    KakaoOauthStrategy = __decorateClass([
+      Injectable()
+    ], KakaoOauthStrategy);
+    providers.push(KakaoOauthStrategy);
+  }
+  if (ssoOptions.naver) {
+    let NaverOauthStrategy = class extends PassportStrategy(NaverStrategy, "naver") {
+      constructor() {
+        super({ ...ssoOptions.naver, callbackURL: `${origin}/user/naver/callback` });
+      }
+      validate(jwt2, refreshToken, profile) {
+        return {
+          name: profile.displayName,
+          email: profile._json.email,
+          password: profile.id
+        };
+      }
+    };
+    NaverOauthStrategy = __decorateClass([
+      Injectable()
+    ], NaverOauthStrategy);
+    providers.push(NaverOauthStrategy);
+  }
+  if (ssoOptions.github) {
+    let GithubOauthStrategy = class extends PassportStrategy(GithubStrategy, "github") {
+      constructor() {
+        super({ ...ssoOptions.github, callbackURL: `${origin}/user/github/callback`, scope: ["user"] });
+      }
+      validate(accessToken, _refreshToken, profile) {
+        return profile;
+      }
+    };
+    GithubOauthStrategy = __decorateClass([
+      Injectable()
+    ], GithubOauthStrategy);
+    providers.push(GithubOauthStrategy);
+  }
+  if (ssoOptions.google) {
+    let GoogleOauthStrategy = class extends PassportStrategy(GoogleStrategy, "google") {
+      constructor() {
+        super({ ...ssoOptions.google, callbackURL: `${origin}/user/google/callback`, scope: ["email", "profile"] });
+      }
+      validate(_accessToken, _refreshToken, profile) {
+        return profile;
+      }
+    };
+    GoogleOauthStrategy = __decorateClass([
+      Injectable()
+    ], GoogleOauthStrategy);
+    providers.push(GoogleOauthStrategy);
+  }
+  if (ssoOptions.facebook) {
+    let FacebookOauthStrategy = class extends PassportStrategy(FacebookStrategy, "facebook") {
+      constructor() {
+        super({
+          ...ssoOptions.facebook,
+          callbackURL: `${origin}/user/facebook/callback`,
+          scope: ["email"],
+          profileFields: ["emails", "name"]
+        });
+      }
+      validate(_accessToken, _refreshToken, profile) {
+        return profile;
+      }
+    };
+    FacebookOauthStrategy = __decorateClass([
+      Injectable()
+    ], FacebookOauthStrategy);
+    providers.push(FacebookOauthStrategy);
+  }
+  if (ssoOptions.apple) {
+    let AppleOauthStrategy = class extends PassportStrategy(AppleStrategy, "apple") {
+      constructor() {
+        super({
+          ...ssoOptions.apple,
+          callbackURL: `${origin}/user/apple/callback`,
+          passReqToCallback: true,
+          scope: ["name", "email"]
+        });
+      }
+      validate(req, accessToken, refreshToken, idToken, profile, cb) {
+        cb(null, idToken);
+      }
+    };
+    AppleOauthStrategy = __decorateClass([
+      Injectable()
+    ], AppleOauthStrategy);
+    providers.push(AppleOauthStrategy);
+  }
+  return providers;
+};
+const verifyAppleUser = async (payload, origin, sso) => {
+  const signinAgent = appleSignin;
+  const clientSecret = signinAgent.getClientSecret({
+    clientID: sso.clientID,
+    teamId: sso.teamID,
+    keyIdentifier: sso.keyID,
+    privateKeyPath: sso.keyFilePath
+  });
+  const tokens = await signinAgent.getAuthorizationToken(payload.code, {
+    clientID: sso.clientID,
+    clientSecret,
+    redirectUri: `${origin}/user/apple/callback`
+  });
+  if (!tokens.id_token) {
+    throw new Error("No id_token found in Apple's response");
+  }
+  const data = jwt.decode(tokens.id_token);
+  return { tokens, data };
+};
+export {
+  getSsoProviders,
+  verifyAppleUser
+};

package/src/verifyPayment.mjs

@@ -0,0 +1,17 @@
+import iap from "iap";
+const verifyPayment = async (payment) => {
+  return new Promise(
+    (resolve, reject) => (
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      iap.verifyPayment(payment.platform, { ...payment }, (error, response) => {
+        if (error)
+          reject(`App Purchase Verify Failed. ${response}`);
+        else
+          resolve(response);
+      })
+    )
+  );
+};
+export {
+  verifyPayment
+};