@supabase/gotrue-js 2.40.0 → 2.41.0

package/src/lib/helpers.ts

@@ -282,3 +282,114 @@ export async function generatePKCEChallenge(verifier: string) {
   const hashed = await sha256(verifier)
   return base64urlencode(hashed)
 }
+
+const STACK_GUARD_PREFIX = `__stack_guard__`
+const STACK_GUARD_SUFFIX = `__`
+
+// Firefox and WebKit based browsers encode the stack entry differently, but
+// they all include the function name. So instead of trying to parse the entry,
+// we're only looking for the special string `__stack_guard__${guardName}__`.
+// Guard names can only be letters with dashes or underscores.
+//
+// Example Firefox stack trace:
+// ```
+// __stack_guard__EXAMPLE__@debugger eval code:1:55
+// @debugger eval code:1:3
+// ```
+//
+// Example WebKit/Chrome stack trace:
+// ```
+// Error
+//  at Object.__stack_guard__EXAMPLE__ (<anonymous>:1:55)
+//  at <anonymous>:1:13
+// ```
+//
+const STACK_ENTRY_REGEX = /__stack_guard__([a-zA-Z0-9_-]+)__/
+
+let STACK_GUARD_CHECKED = false
+let STACK_GUARD_CHECK_FN: () => Promise<void> // eslint-disable-line prefer-const
+
+/**
+ * Checks if the current caller of the function is in a {@link
+ * #stackGuard} of the provided `name`. Works by looking through
+ * the stack trace of an `Error` object for a special function
+ * name (generated by {@link #stackGuard}).
+ *
+ * @param name The name of the stack guard to check for. Must be `[a-zA-Z0-9_-]` only.
+ */
+export function isInStackGuard(name: string): boolean {
+  STACK_GUARD_CHECK_FN()
+
+  let error: Error
+
+  try {
+    throw new Error()
+  } catch (e: any) {
+    error = e
+  }
+
+  const stack = error.stack?.split('\n') ?? []
+
+  for (let i = 0; i < stack.length; i += 1) {
+    const entry = stack[i]
+    const match = entry.match(STACK_ENTRY_REGEX)
+
+    if (match && match[1] === name) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Creates a minification resistant stack guard, i.e. if you
+ * call {@link #isInStackGuard} from within the `fn` parameter
+ * function, you will always get `true` otherwise it will be
+ * `false`.
+ *
+ * Works by dynamically defining a function name before calling
+ * into `fn`, which is then parsed from the stack trace on an
+ * `Error` object within {@link #isInStackGuard}.
+ *
+ * @param name The name of the stack guard. Must be `[a-zA-Z0-9_-]` only.
+ * @param fn The async/await function to be run within the stack guard.
+ */
+export async function stackGuard<R>(name: string, fn: () => Promise<R>): Promise<R> {
+  await STACK_GUARD_CHECK_FN()
+
+  const guardName = `${STACK_GUARD_PREFIX}${name}${STACK_GUARD_SUFFIX}`
+
+  const guardFunc: {
+    [funcName: string]: () => Promise<R>
+  } = {
+    // per ECMAScript rules, this defines a new function with the dynamic name
+    // contained in the `guardName` variable
+    // this function name shows up in stack traces and is resistant to mangling
+    // from minification processes as it is determined at runtime
+    [guardName]: async () => await fn(),
+  }
+
+  return await guardFunc[guardName]()
+}
+
+// In certain cases, if this file is transpiled using an ES2015 target, or is
+// running in a JS engine that does not support async/await stack traces, this
+// function will log a single warning message.
+STACK_GUARD_CHECK_FN = async () => {
+  if (!STACK_GUARD_CHECKED) {
+    STACK_GUARD_CHECKED = true
+
+    await stackGuard('ENV_CHECK', async () => {
+      const result = isInStackGuard('ENV_CHECK')
+
+      if (!result) {
+        console.warn(
+          '@supabase/gotrue-js: Stack guards not supported in this environment. Generally not an issue but may point to a very conservative transpilation environment (use ES2017 or above) that implements async/await with generators, or this is a JavaScript engine that does not support async/await stack traces.'
+        )
+      }
+
+      return result
+    })
+  }
+}

package/src/lib/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '2.40.0'
+export const version = '2.41.0'