quanvio-react-native-sdk 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,199 @@
-# Temporary Holding Version
+# quanvio-react-native-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This is Quanvio's SDK for react-native will allow you to easily connect your application to the Quanvio One authentication system (https://one.quanvio.com) without having to implement it from scratch.
+Quanvio SDK is very simple to use. We will show you the steps below.
+
+## Usage in NPM environment
+
+### Installation
+
+~~~shell script
+# NPM
+npm i quanvio-react-native-sdk @react-native-async-storage/async-storage
+
+# Yarn
+yarn add quanvio-react-native-sdk @react-native-async-storage/async-storage
+~~~
+
+### Init SDK
+
+Initialization requires 7 parameters, which are all string type:
+
+| Name (in order)  | Must | Description                                         |
+| ---------------- | ---- | --------------------------------------------------- |
+| serverUrl  | Yes  | your Quanvio One server URL, e.g. `https://one.quanvio.com` |
+| clientId         | Yes  | the Client ID of your Quanvio One application|
+| appName           | Yes  | the name of your Quanvio One application |
+| organizationName     | Yes  | the name of the organization connected with your Quanvio One application                    |
+| redirectPath     | No  | the redirect URL for your Quanvio One application, e.g., `myapp://callback`; a path like `/callback` is prefixed with the current origin on the web, will be `/callback` if not provided              |
+| signinPath     | No  | the path of the signin URL for your Quanvio One application, will be `/api/signin` if not provided              |
+
+```typescript
+import SDK from 'quanvio-react-native-sdk'
+
+const sdkConfig = {
+  serverUrl: 'https://one.quanvio.com',
+  clientId: 'b800a86702dd4d29ec4d',
+  appName: 'app-example',
+  organizationName: 'quanvio',
+  redirectPath: 'http://localhost:5000/callback',
+  signinPath: '/api/signin',
+};
+const sdk = new SDK(sdkConfig)
+// call sdk to handle
+```
+
+## Usage in Expo
+
+The SDK works in the Expo managed workflow without `react-native-webview` or manual deep-link handling: `signin()` opens the Quanvio One login page in the system auth browser and returns the access token after the redirect.
+
+### Installation
+
+~~~shell script
+npx expo install quanvio-react-native-sdk @react-native-async-storage/async-storage expo-auth-session expo-web-browser expo-crypto react-native-get-random-values
+~~~
+
+### Configure the redirect URI
+
+1. Add a scheme to `app.json`, so that the app can be opened by the redirect URI:
+
+```json
+{
+  "expo": {
+    "scheme": "myapp"
+  }
+}
+```
+
+2. Add the redirect URI to the **Redirect URLs** of your application in Quanvio One. `AuthSession.makeRedirectUri({ path: 'callback' })` returns `myapp://callback` in a standalone or development build, and `exp://<your-ip>:8081/--/callback` in Expo Go; add the one you use.
+
+### Sign in
+
+```typescript
+// must be imported before the SDK: the PKCE code is generated with crypto.getRandomValues(), which Hermes does not provide
+import 'react-native-get-random-values';
+import * as AuthSession from 'expo-auth-session';
+import * as WebBrowser from 'expo-web-browser';
+import SDK from 'quanvio-react-native-sdk';
+
+WebBrowser.maybeCompleteAuthSession();
+
+const sdk = new SDK({
+  serverUrl: 'https://one.quanvio.com',
+  clientId: 'b800a86702dd4d29ec4d',
+  appName: 'app-example',
+  organizationName: 'quanvio',
+  redirectPath: AuthSession.makeRedirectUri({ path: 'callback' }),
+});
+
+const login = async () => {
+  const token = await sdk.signin(WebBrowser.openAuthSessionAsync);
+  if (token) {
+    const user = sdk.JwtDecode(token);
+  }
+};
+```
+
+`silentSignin()` relies on a hidden iframe and only works on the web; in native apps it calls `onFailure`.
+
+## Usage in vanilla Javascript
+
+### Import and init SDK
+
+Initialization parameters are consistent with the previous node.js section:
+
+```javascript
+<!--init the SDK-->
+  import SDK from 'quanvio-react-native-sdk'
+  const sdkConfig = {
+    serverUrl: 'https://one.quanvio.com',
+    clientId: 'b800a86702dd4d29ec4d',
+    appName: 'app-example',
+    organizationName: 'quanvio',
+    redirectPath: 'http://localhost:5000/callback',
+    signinPath: '/api/signin',
+  };
+  const sdk = new SDK(sdkConfig)
+```
+
+### Call functions in SDK
+
+```javascript
+  // call sdk to handle
+  sdk.getSignupUrl();
+```
+
+## API reference interface
+
+#### Get sign up url
+
+```typescript
+getSignupUrl()
+```
+
+Return the Quanvio One url that navigates to the registration screen
+
+#### Get sign in url
+
+```typescript
+getSigninUrl()
+```
+
+Return the Quanvio One url that navigates to the login screen
+
+#### Get user profile page url
+
+```typescript
+getUserProfileUrl(userName, account)
+```
+
+Return the url to navigate to a specific user's Quanvio One personal page
+
+#### Get my profile page url
+
+```typescript
+getMyProfileUrl(account)
+```
+
+#### signin
+
+```typescript
+signin(openAuthSession) // e.g., sdk.signin(WebBrowser.openAuthSessionAsync)
+```
+
+Open the login page with `openAuthSession(url, redirectUri)`, which should resolve to `{ type: 'success', url }` after the browser is redirected back, and return the access token. Return `undefined` if the user cancels the login.
+
+#### getAccessToken
+
+```typescript
+getAccessToken(redirectUrl); // http://localhost:5000/callback?code=b75bc5c5ac65ffa516e5&state=gjmfdgqf498
+```
+
+Handle the callback url from Quanvio One, call the back-end api to complete the login process
+
+#### Determine whether silent sign-in is being used
+
+```typescript
+isSilentSigninRequested()
+```
+
+We usually use this method to determine if silent login is being used. By default, if the silentSignin parameter is included in the URL and equals one, this method will return true. Of course, you can also use any method you prefer.
+
+#### silentSignin
+
+````typescript
+silentSignin(onSuccess, onFailure)
+````
+
+First, let's explain the two parameters of this method, which are the callback methods for successful and failed login. Next, I will describe the execution process of this method. We will create a hidden "iframe" element to redirect to the login page for authentication, thereby achieving the effect of silent sign-in.
+
+#### JwtDecode
+
+````typescript
+JwtDecode(jwtToken)
+````
+
+
+## License
+
+[Apache-2.0](LICENSE)

package/lib/cjs/index.d.ts

@@ -0,0 +1,3 @@
+import QuanvioSdk from './sdk';
+export type { QuanvioConfig, Account, AuthSessionResult, OpenAuthSession } from './sdk';
+export default QuanvioSdk;

package/lib/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+// Copyright 2021 The casbin Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("./sdk");
+exports.default = sdk_1.default;

package/lib/cjs/sdk.d.ts

@@ -0,0 +1,47 @@
+export interface QuanvioConfig {
+    serverUrl: string;
+    clientId: string;
+    appName: string;
+    organizationName: string;
+    redirectPath?: string;
+    signinPath?: string;
+}
+export interface Account {
+    organization: string;
+    username: string;
+    type: string;
+    name: string;
+    avatar: string;
+    email: string;
+    phone: string;
+    affiliation: string;
+    tag: string;
+    language: string;
+    score: number;
+    isAdmin: boolean;
+    accessToken: string;
+}
+export interface AuthSessionResult {
+    type: string;
+    url?: string;
+}
+export type OpenAuthSession = (url: string, redirectUri: string) => Promise<AuthSessionResult>;
+declare class QuanvioSdk {
+    private config;
+    constructor(config: QuanvioConfig);
+    private getPkce;
+    getSignupUrl(enablePassword?: boolean): Promise<string>;
+    getOrSaveState(): Promise<string>;
+    clearState(): void;
+    getRedirectUri(): string;
+    getSigninUrl(): Promise<string>;
+    signin(openAuthSession: OpenAuthSession): Promise<string | undefined>;
+    getUserProfileUrl(userName: string, account: Account): string;
+    getMyProfileUrl(account: Account, returnUrl?: String): string;
+    JwtDecode(token: string): unknown;
+    private static getQueryParam;
+    getAccessToken(redirectUrl: string): Promise<any>;
+    isSilentSigninRequested(): boolean;
+    silentSignin(onSuccess: (message: any) => void, onFailure: (message: any) => void): void;
+}
+export default QuanvioSdk;

package/lib/cjs/sdk.js

@@ -0,0 +1,201 @@
+"use strict";
+// Copyright 2021 The casbin Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the 'License');
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an 'AS IS' BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_storage_1 = require("@react-native-async-storage/async-storage");
+const jwt_decode_1 = require("jwt-decode");
+const pkce_challenge_1 = require("pkce-challenge");
+class QuanvioSdk {
+    constructor(config) {
+        this.config = config;
+        if (config.redirectPath === undefined || config.redirectPath === null) {
+            this.config.redirectPath = '/callback';
+        }
+    }
+    // The PKCE pair is kept in AsyncStorage (localStorage on the web) instead of memory, so the code verifier
+    // survives the page redirect to Quanvio One and back, and is found by a new QuanvioSdk instance after the redirect.
+    async getPkce() {
+        const savedPkce = await async_storage_1.default.getItem('quanvio-pkce');
+        if (savedPkce !== null) {
+            return JSON.parse(savedPkce);
+        }
+        const pkce = await (0, pkce_challenge_1.default)();
+        await async_storage_1.default.setItem('quanvio-pkce', JSON.stringify(pkce));
+        return pkce;
+    }
+    async getSignupUrl(enablePassword = true) {
+        const signinUrl = await this.getSigninUrl();
+        if (enablePassword) {
+            async_storage_1.default.setItem('signinUrl', signinUrl);
+            return `${this.config.serverUrl.trim()}/signup/${this.config.appName}`;
+        }
+        else {
+            return signinUrl.replace('/login/oauth/authorize', '/signup/oauth/authorize');
+        }
+    }
+    async getOrSaveState() {
+        const state = await async_storage_1.default.getItem('quanvio-state');
+        if (state !== null) {
+            return state;
+        }
+        else {
+            const state = Math.random().toString(36).slice(2);
+            async_storage_1.default.setItem('quanvio-state', state);
+            return state;
+        }
+    }
+    clearState() {
+        async_storage_1.default.removeItem('quanvio-state');
+        async_storage_1.default.removeItem('quanvio-pkce');
+    }
+    getRedirectUri() {
+        var _a;
+        const redirectPath = (_a = this.config.redirectPath) !== null && _a !== void 0 ? _a : '/callback';
+        if (redirectPath.includes('://') || typeof window === 'undefined' || !window.location) {
+            return redirectPath;
+        }
+        return `${window.location.origin}${redirectPath}`;
+    }
+    async getSigninUrl() {
+        const redirectUri = this.getRedirectUri();
+        const scope = 'read';
+        const state = await this.getOrSaveState();
+        const pkce = await this.getPkce();
+        return `${this.config.serverUrl.trim()}/login/oauth/authorize?client_id=${this.config.clientId}&response_type=code&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${scope}&state=${state}&code_challenge=${pkce.code_challenge}&code_challenge_method=S256`;
+    }
+    // Opens the Quanvio One login page with the given auth browser, e.g., WebBrowser.openAuthSessionAsync for Expo,
+    // and exchanges the returned code for an access token. Returns undefined if the user cancels the login.
+    async signin(openAuthSession) {
+        const signinUrl = await this.getSigninUrl();
+        const result = await openAuthSession(signinUrl, this.getRedirectUri());
+        if (result.type !== 'success' || !result.url) {
+            return undefined;
+        }
+        return this.getAccessToken(result.url);
+    }
+    getUserProfileUrl(userName, account) {
+        let param = '';
+        if (account !== undefined && account !== null) {
+            param = `?access_token=${account.accessToken}`;
+        }
+        return `${this.config.serverUrl.trim()}/users/${this.config.organizationName}/${userName}${param}`;
+    }
+    getMyProfileUrl(account, returnUrl = '') {
+        let params = '';
+        if (account !== undefined && account !== null) {
+            params = `?access_token=${account.accessToken}`;
+            if (returnUrl !== '') {
+                params += `&returnUrl=${returnUrl}`;
+            }
+        }
+        else if (returnUrl !== '') {
+            params = `?returnUrl=${returnUrl}`;
+        }
+        return `${this.config.serverUrl.trim()}/account${params}`;
+    }
+    JwtDecode(token) {
+        return (0, jwt_decode_1.default)(token);
+    }
+    // URLSearchParams is not fully implemented in React Native, so parse the query string by hand
+    static getQueryParam(url, name) {
+        const query = url.split('#')[0].split('?')[1];
+        if (!query) {
+            return null;
+        }
+        for (const pair of query.split('&')) {
+            const [key, value = ''] = pair.split('=');
+            if (decodeURIComponent(key) === name) {
+                return decodeURIComponent(value.replace(/\+/g, ' '));
+            }
+        }
+        return null;
+    }
+    async getAccessToken(redirectUrl) {
+        var _a;
+        const redirectUri = this.getRedirectUri();
+        if (redirectUrl.startsWith(redirectUri)) {
+            const code = QuanvioSdk.getQueryParam(redirectUrl, 'code');
+            if (code === null) {
+                console.error('Error during Signin Request:', (_a = QuanvioSdk.getQueryParam(redirectUrl, 'error')) !== null && _a !== void 0 ? _a : redirectUrl);
+                return;
+            }
+            const state = QuanvioSdk.getQueryParam(redirectUrl, 'state');
+            if (state !== null) {
+                await async_storage_1.default.setItem('quanvio-state', state);
+            }
+            const codeVerifier = (await this.getPkce()).code_verifier;
+            try {
+                const response = await fetch(`${this.config.serverUrl.trim()}/api/login/oauth/access_token`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                    body: `client_id=${this.config.clientId}&grant_type=authorization_code&code=${encodeURIComponent(code)}&redirect_uri=${encodeURIComponent(redirectUri)}&code_verifier=${codeVerifier}`,
+                    credentials: 'include',
+                });
+                if (response.ok) {
+                    const responseData = await response.json();
+                    const token = responseData.access_token;
+                    return token;
+                }
+                else {
+                    console.error('Error during AccessToken Request:', response);
+                }
+            }
+            catch (error) {
+                console.error('Error during Signin Request:', error);
+            }
+            finally {
+                // a code verifier is only valid for one authorization code, the next signin gets a new one
+                await async_storage_1.default.removeItem('quanvio-pkce');
+            }
+        }
+    }
+    isSilentSigninRequested() {
+        if (typeof window === 'undefined' || !window.location) {
+            return false;
+        }
+        const params = new URLSearchParams(window.location.search);
+        return params.get('silentSignin') === '1';
+    }
+    silentSignin(onSuccess, onFailure) {
+        if (typeof document === 'undefined') {
+            onFailure({ tag: 'Casdoor', type: 'SilentSignin', data: 'silentSignin is not supported in React Native' });
+            return;
+        }
+        const iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        this.getSigninUrl().then(signinUrl => {
+            iframe.src = `${signinUrl}&silentSignin=1`;
+            document.body.appendChild(iframe);
+        });
+        const handleMessage = (event) => {
+            if (window !== window.parent) {
+                return null;
+            }
+            const message = event.data;
+            if (message.tag !== 'Casdoor' || message.type !== 'SilentSignin') {
+                return;
+            }
+            if (message.data === 'success') {
+                onSuccess(message);
+            }
+            else {
+                onFailure(message);
+            }
+        };
+        window.addEventListener('message', handleMessage);
+    }
+}
+exports.default = QuanvioSdk;

package/lib/esm/index.d.ts

@@ -0,0 +1,3 @@
+import QuanvioSdk from './sdk';
+export type { QuanvioConfig, Account, AuthSessionResult, OpenAuthSession } from './sdk';
+export default QuanvioSdk;

package/lib/esm/index.js

@@ -0,0 +1,15 @@
+// Copyright 2021 The casbin Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import QuanvioSdk from './sdk';
+export default QuanvioSdk;

package/lib/esm/sdk.d.ts

@@ -0,0 +1,47 @@
+export interface QuanvioConfig {
+    serverUrl: string;
+    clientId: string;
+    appName: string;
+    organizationName: string;
+    redirectPath?: string;
+    signinPath?: string;
+}
+export interface Account {
+    organization: string;
+    username: string;
+    type: string;
+    name: string;
+    avatar: string;
+    email: string;
+    phone: string;
+    affiliation: string;
+    tag: string;
+    language: string;
+    score: number;
+    isAdmin: boolean;
+    accessToken: string;
+}
+export interface AuthSessionResult {
+    type: string;
+    url?: string;
+}
+export type OpenAuthSession = (url: string, redirectUri: string) => Promise<AuthSessionResult>;
+declare class QuanvioSdk {
+    private config;
+    constructor(config: QuanvioConfig);
+    private getPkce;
+    getSignupUrl(enablePassword?: boolean): Promise<string>;
+    getOrSaveState(): Promise<string>;
+    clearState(): void;
+    getRedirectUri(): string;
+    getSigninUrl(): Promise<string>;
+    signin(openAuthSession: OpenAuthSession): Promise<string | undefined>;
+    getUserProfileUrl(userName: string, account: Account): string;
+    getMyProfileUrl(account: Account, returnUrl?: String): string;
+    JwtDecode(token: string): unknown;
+    private static getQueryParam;
+    getAccessToken(redirectUrl: string): Promise<any>;
+    isSilentSigninRequested(): boolean;
+    silentSignin(onSuccess: (message: any) => void, onFailure: (message: any) => void): void;
+}
+export default QuanvioSdk;

package/lib/esm/sdk.js

@@ -0,0 +1,199 @@
+// Copyright 2021 The casbin Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the 'License');
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an 'AS IS' BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import jwtDecode from 'jwt-decode';
+import pkceChallenge from 'pkce-challenge';
+class QuanvioSdk {
+    constructor(config) {
+        this.config = config;
+        if (config.redirectPath === undefined || config.redirectPath === null) {
+            this.config.redirectPath = '/callback';
+        }
+    }
+    // The PKCE pair is kept in AsyncStorage (localStorage on the web) instead of memory, so the code verifier
+    // survives the page redirect to Quanvio One and back, and is found by a new QuanvioSdk instance after the redirect.
+    async getPkce() {
+        const savedPkce = await AsyncStorage.getItem('quanvio-pkce');
+        if (savedPkce !== null) {
+            return JSON.parse(savedPkce);
+        }
+        const pkce = await pkceChallenge();
+        await AsyncStorage.setItem('quanvio-pkce', JSON.stringify(pkce));
+        return pkce;
+    }
+    async getSignupUrl(enablePassword = true) {
+        const signinUrl = await this.getSigninUrl();
+        if (enablePassword) {
+            AsyncStorage.setItem('signinUrl', signinUrl);
+            return `${this.config.serverUrl.trim()}/signup/${this.config.appName}`;
+        }
+        else {
+            return signinUrl.replace('/login/oauth/authorize', '/signup/oauth/authorize');
+        }
+    }
+    async getOrSaveState() {
+        const state = await AsyncStorage.getItem('quanvio-state');
+        if (state !== null) {
+            return state;
+        }
+        else {
+            const state = Math.random().toString(36).slice(2);
+            AsyncStorage.setItem('quanvio-state', state);
+            return state;
+        }
+    }
+    clearState() {
+        AsyncStorage.removeItem('quanvio-state');
+        AsyncStorage.removeItem('quanvio-pkce');
+    }
+    getRedirectUri() {
+        var _a;
+        const redirectPath = (_a = this.config.redirectPath) !== null && _a !== void 0 ? _a : '/callback';
+        if (redirectPath.includes('://') || typeof window === 'undefined' || !window.location) {
+            return redirectPath;
+        }
+        return `${window.location.origin}${redirectPath}`;
+    }
+    async getSigninUrl() {
+        const redirectUri = this.getRedirectUri();
+        const scope = 'read';
+        const state = await this.getOrSaveState();
+        const pkce = await this.getPkce();
+        return `${this.config.serverUrl.trim()}/login/oauth/authorize?client_id=${this.config.clientId}&response_type=code&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${scope}&state=${state}&code_challenge=${pkce.code_challenge}&code_challenge_method=S256`;
+    }
+    // Opens the Quanvio One login page with the given auth browser, e.g., WebBrowser.openAuthSessionAsync for Expo,
+    // and exchanges the returned code for an access token. Returns undefined if the user cancels the login.
+    async signin(openAuthSession) {
+        const signinUrl = await this.getSigninUrl();
+        const result = await openAuthSession(signinUrl, this.getRedirectUri());
+        if (result.type !== 'success' || !result.url) {
+            return undefined;
+        }
+        return this.getAccessToken(result.url);
+    }
+    getUserProfileUrl(userName, account) {
+        let param = '';
+        if (account !== undefined && account !== null) {
+            param = `?access_token=${account.accessToken}`;
+        }
+        return `${this.config.serverUrl.trim()}/users/${this.config.organizationName}/${userName}${param}`;
+    }
+    getMyProfileUrl(account, returnUrl = '') {
+        let params = '';
+        if (account !== undefined && account !== null) {
+            params = `?access_token=${account.accessToken}`;
+            if (returnUrl !== '') {
+                params += `&returnUrl=${returnUrl}`;
+            }
+        }
+        else if (returnUrl !== '') {
+            params = `?returnUrl=${returnUrl}`;
+        }
+        return `${this.config.serverUrl.trim()}/account${params}`;
+    }
+    JwtDecode(token) {
+        return jwtDecode(token);
+    }
+    // URLSearchParams is not fully implemented in React Native, so parse the query string by hand
+    static getQueryParam(url, name) {
+        const query = url.split('#')[0].split('?')[1];
+        if (!query) {
+            return null;
+        }
+        for (const pair of query.split('&')) {
+            const [key, value = ''] = pair.split('=');
+            if (decodeURIComponent(key) === name) {
+                return decodeURIComponent(value.replace(/\+/g, ' '));
+            }
+        }
+        return null;
+    }
+    async getAccessToken(redirectUrl) {
+        var _a;
+        const redirectUri = this.getRedirectUri();
+        if (redirectUrl.startsWith(redirectUri)) {
+            const code = QuanvioSdk.getQueryParam(redirectUrl, 'code');
+            if (code === null) {
+                console.error('Error during Signin Request:', (_a = QuanvioSdk.getQueryParam(redirectUrl, 'error')) !== null && _a !== void 0 ? _a : redirectUrl);
+                return;
+            }
+            const state = QuanvioSdk.getQueryParam(redirectUrl, 'state');
+            if (state !== null) {
+                await AsyncStorage.setItem('quanvio-state', state);
+            }
+            const codeVerifier = (await this.getPkce()).code_verifier;
+            try {
+                const response = await fetch(`${this.config.serverUrl.trim()}/api/login/oauth/access_token`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                    body: `client_id=${this.config.clientId}&grant_type=authorization_code&code=${encodeURIComponent(code)}&redirect_uri=${encodeURIComponent(redirectUri)}&code_verifier=${codeVerifier}`,
+                    credentials: 'include',
+                });
+                if (response.ok) {
+                    const responseData = await response.json();
+                    const token = responseData.access_token;
+                    return token;
+                }
+                else {
+                    console.error('Error during AccessToken Request:', response);
+                }
+            }
+            catch (error) {
+                console.error('Error during Signin Request:', error);
+            }
+            finally {
+                // a code verifier is only valid for one authorization code, the next signin gets a new one
+                await AsyncStorage.removeItem('quanvio-pkce');
+            }
+        }
+    }
+    isSilentSigninRequested() {
+        if (typeof window === 'undefined' || !window.location) {
+            return false;
+        }
+        const params = new URLSearchParams(window.location.search);
+        return params.get('silentSignin') === '1';
+    }
+    silentSignin(onSuccess, onFailure) {
+        if (typeof document === 'undefined') {
+            onFailure({ tag: 'Casdoor', type: 'SilentSignin', data: 'silentSignin is not supported in React Native' });
+            return;
+        }
+        const iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        this.getSigninUrl().then(signinUrl => {
+            iframe.src = `${signinUrl}&silentSignin=1`;
+            document.body.appendChild(iframe);
+        });
+        const handleMessage = (event) => {
+            if (window !== window.parent) {
+                return null;
+            }
+            const message = event.data;
+            if (message.tag !== 'Casdoor' || message.type !== 'SilentSignin') {
+                return;
+            }
+            if (message.data === 'success') {
+                onSuccess(message);
+            }
+            else {
+                onFailure(message);
+            }
+        };
+        window.addEventListener('message', handleMessage);
+    }
+}
+export default QuanvioSdk;

package/package.json

@@ -1,6 +1,80 @@
 {
   "name": "quanvio-react-native-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "React Native client SDK for the Quanvio One authentication system (https://one.quanvio.com)",
+  "main": "lib/cjs/index.js",
+  "typings": "lib/cjs/index.d.ts",
+  "module": "lib/esm/index.js",
+  "license": "Apache-2.0",
+  "scripts": {
+    "prepack": "run-s build",
+    "postpack": "run-s clean",
+    "build": "run-s clean && run-p build:*",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "clean": "rimraf lib",
+    "test": "jest",
+    "coverage": "jest --coverage",
+    "semantic-release": "semantic-release"
+  },
+  "jest": {
+    "maxConcurrency": 1,
+    "maxWorkers": 1,
+    "testTimeout": 30000,
+    "testEnvironment": "jsdom",
+    "transform": {
+      "^.+\\.(t|j)sx?$": "ts-jest"
+    },
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ]
+  },
+  "devDependencies": {
+    "@react-native-async-storage/async-storage": "^1.19.3",
+    "@types/jest": "^27.0.2",
+    "jest": "^27.2.1",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^3.0.2",
+    "semantic-release": "^25.0.9",
+    "ts-jest": "^27.0.5",
+    "typescript": "^4.5.5"
+  },
+  "files": [
+    "lib"
+  ],
+  "keywords": [
+    "auth",
+    "authn",
+    "authentication",
+    "sso",
+    "oauth",
+    "oidc",
+    "quanvio"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quanvio/quanvio-react-native-sdk.git"
+  },
+  "author": {
+    "name": "Quanvio",
+    "email": "support@quanvio.com",
+    "url": "https://quanvio.com"
+  },
+  "bugs": {
+    "url": "https://github.com/quanvio/quanvio-react-native-sdk/issues"
+  },
+  "homepage": "https://github.com/quanvio/quanvio-react-native-sdk",
+  "dependencies": {
+    "jwt-decode": "^3.1.2",
+    "pkce-challenge": "3.1.0"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "^1.19.3 || ^2.0.0"
+  }
+}