@ianlucas/remix-auth-steam 2.0.2 → 2.1.0

package/README.md

@@ -1,6 +1,6 @@
 # remix-auth-steam
 
-This is a [Steam](https://steamcommunity.com/) strategy for [remix-auth](https://github.com/sergiodxa/remix-auth) library.
+> A Steam strategy for Remix Auth library
 
 ## Install
 

package/dist/index.js

@@ -3,10 +3,35 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import { redirect } from "@remix-run/server-runtime";
-import { Strategy } from "remix-auth";
 import OpenID from "openid";
-import { PromiseAuthenticate, PromiseVerifyAssertion } from "./promises.js";
+import { Strategy } from "remix-auth";
 import SteamAPI from "steamapi";
+function authenticateToSteam(relyingParty) {
+    return new Promise((resolve, reject) => {
+        relyingParty.authenticate("https://steamcommunity.com/openid", false, (err, url) => {
+            if (err) {
+                return reject(err);
+            }
+            if (!url) {
+                return reject("Got no URL from authenticate method");
+            }
+            return resolve(url);
+        });
+    });
+}
+function verifySteamAssertion(relyingParty, request) {
+    return new Promise((resolve, reject) => {
+        relyingParty.verifyAssertion(request, (err, result) => {
+            if (err) {
+                return reject(err);
+            }
+            if (!result) {
+                return reject("No result from verifyAssertion");
+            }
+            return resolve(result);
+        });
+    });
+}
 export class SteamStrategy extends Strategy {
     name = "steam";
     options;
@@ -15,11 +40,11 @@ export class SteamStrategy extends Strategy {
         this.options = options;
     }
     async authenticate(request, sessionStorage, options) {
-        const { apiKey, returnURL, realm } = typeof this.options === "function" ? await this.options() : this.options;
+        const { apiKey, returnURL, realm } = typeof this.options === "function" ? await this.options(request) : this.options;
         const relyingParty = new OpenID.RelyingParty(returnURL, realm ?? null, true, false, []);
         const steamApi = new SteamAPI(apiKey);
         try {
-            const result = await PromiseVerifyAssertion(relyingParty, request);
+            const result = await verifySteamAssertion(relyingParty, request);
             if (!result.authenticated || !result.claimedIdentifier)
                 return this.failure(`Not authenticated from result`, request, sessionStorage, options);
             try {
@@ -34,8 +59,7 @@ export class SteamStrategy extends Strategy {
             }
         }
         catch {
-            const result = await PromiseAuthenticate(relyingParty);
-            throw redirect(result);
+            throw redirect(await authenticateToSteam(relyingParty));
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ianlucas/remix-auth-steam",
-    "version": "2.0.2",
+    "version": "2.1.0",
     "description": "Remix authentication strategy for Steam",
     "license": "MIT",
     "author": "Ian Lucas",

package/dist/promises.d.ts

@@ -1,6 +0,0 @@
-import type OpenID from "openid";
-export declare const PromiseAuthenticate: (relyingParty: OpenID.RelyingParty) => Promise<string>;
-export declare const PromiseVerifyAssertion: (relyingParty: OpenID.RelyingParty, req: Request) => Promise<{
-    authenticated: boolean;
-    claimedIdentifier?: string | undefined;
-}>;

package/dist/promises.js

@@ -1,26 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Ian Lucas. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-export const PromiseAuthenticate = (relyingParty) => new Promise((resolve, reject) => {
-    relyingParty.authenticate("https://steamcommunity.com/openid", false, (err, url) => {
-        if (err) {
-            return reject(err);
-        }
-        if (!url) {
-            return reject("Got no URL from authenticate method");
-        }
-        return resolve(url);
-    });
-});
-export const PromiseVerifyAssertion = (relyingParty, req) => new Promise((resolve, reject) => {
-    relyingParty.verifyAssertion(req, (err, result) => {
-        if (err) {
-            return reject(err);
-        }
-        if (!result) {
-            return reject(`No result from verifyAssertion`);
-        }
-        return resolve(result);
-    });
-});