@fullstackunicorn/auth 1.0.0

package/index.js

@@ -0,0 +1,2 @@
+import '@fullstackunicorn/initialize'
+export { auth } from './modules/auth.js'

package/modules/auth.js

@@ -0,0 +1,134 @@
+import '@fullstackunicorn/initialize'
+import { fsa, axios, jwt, pem } from '#@/index.dep.js'
+
+class Auth {
+
+    constructor() {
+
+        this.isRetry = false
+
+        this.paths = {}
+        this.paths.pem = './index.crt'
+
+        this.vars = {}
+        this.vars.realm = process.env.AUTH_REALM
+        this.vars.client = process.env.AUTH_CLIENT
+
+        this.url = {}
+        this.url.verify = process.env.URL_VERIFY
+        this.url.certificate = process.env.URL_CERTIFICATE
+        this.url.issuer = process.env.URL_ISSUER
+
+    }
+
+    user = async (authToken, method) => {
+        this.isRetry = false
+        try {
+            const token = this.checkToken(authToken)
+            if (!token) return {}
+            const user = await this.verifyToken(token, method)
+            if (!user?.id) return {}
+            return user
+        } catch { return {} }
+    }
+
+    isOffline = method => method === 'GET'
+
+    verifyOffline = async (token, pemKey, options = {}) => {
+        try {
+            const decoded = jwt.verify(token, pemKey, options)
+            return { content: decoded }
+        } catch { return {} }
+    }
+
+    verifyOnline = async token => {
+        try {
+            const res = await axios.post(this.url.verify, { token })
+            if (!res?.data?.verified) return {}
+            const decoded = jwt.decode(token)
+            if (!decoded) return {}
+            return { content: decoded }
+        } catch { return {} }
+    }
+
+    isEligible = (content = {}) => {
+        if (!content?.sub || !content?.exp) return false
+        if (content.iss !== this.url.issuer) return false
+        if (!content?.aud) return false
+        const aud = F3.isArr(content.aud) ? content.aud : [content.aud]
+        if (!aud.includes(this.vars.client)) return false
+        return true
+    }
+
+    verifyToken = async (token, method) => {
+
+        let result = {}
+
+        try {
+
+            const isOffline = this.isOffline(method)
+            if (!isOffline) result = await this.verifyOnline(token)
+            else result = await this.verifyOffline(token, await this.getPem(token))
+            if (!result?.content?.exp && isOffline) return await this.retryVerifyToken(token, method)
+            if (!result?.content?.exp && !isOffline) return {}
+            if (this.isTokenExpired(result.content.exp)) return {}
+            if (!this.isEligible(result.content)) return {}
+            this.isRetry = false
+            return { id: result.content.sub, token }
+
+        } catch { F3.catch.throw('verify-token-failed') }
+
+    }
+
+    retryVerifyToken = async (token, method) => {
+
+        if (this.isRetry) return {}
+        this.isRetry = true
+
+        try {
+            await this.updatePem()
+            return await this.verifyToken(token, method)
+        } catch { F3.catch.throw('retry-verify-token-failed') }
+    }
+
+    isTokenExpired = expiryDate => Date.now() > expiryDate * 1000
+
+    checkToken = authToken => {
+        const isBearer = F3.isStr(authToken) && authToken.startsWith('Bearer ')
+        return isBearer ? authToken.replace('Bearer ', '') : false
+    }
+
+    fetchPem = async () => {
+        try { return await axios.post(this.url.certificate, { realm: this.vars.realm }) }
+        catch { return null }
+    }
+
+    initPem = async () => {
+        try { if (!(await fsa.exists(this.paths.pem))) await this.updatePem() }
+        catch { F3.catch.throw('init-pem-failed') }
+    }
+
+    updatePem = async () => {
+        try {
+            const certificate = {}
+            const pemObject = await this.fetchPem()
+            if (!pemObject?.data?.keys) F3.throw('certificate-fetch-failed')
+            pemObject.data.keys.forEach(key => certificate[key.kid] = pem(key))
+            await fsa.writeJSON(this.paths.pem, certificate)
+            return true
+        } catch { F3.catch.throw('update-pem-failed') }
+    }
+
+    getPem = async token => {
+        try {
+            const file = await fsa.readFile(this.paths.pem)
+            const pemObject = JSON.parse(String(file))
+            const jwtDecoded = jwt.decode(token, { complete: true })
+            return pemObject[jwtDecoded?.header?.kid]
+        } catch { F3.catch.throw('get-pem-failed') }
+    }
+}
+
+const auth = new Auth()
+await auth.initPem()
+export { auth }

package/package.json

@@ -0,0 +1,42 @@
+{
+    "version": "1.0.0",
+    "name": "@fullstackunicorn/auth",
+    "author": "lucanigido (https://fullstackunicorn.dev/author/lucanigido)",
+    "description": "A component to implement OAuth in your project",
+    "license": "MIT",
+    "type": "module",
+    "private": false,
+    "readme": "package.readme.md",
+    "main": "index.js",
+    "files": [
+        "index.js",
+        "index.dep.js",
+        "modules/"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://gitlab.com/fullstackunicorn/auth.git"
+    },
+    "keywords": [
+        "authentication",
+        "OAuth",
+        "react-native",
+        "react",
+        "fullstackunicorn"
+    ],
+    "imports": {
+        "#@": "./",
+        "#@/*": "./*"
+    },
+    "scripts": {
+        "test": "exit 1",
+        "run": "chmod +x ./config.run.sh && ./config.run.sh"
+    },
+    "dependencies": {
+        "@fullstackunicorn/initialize": "^1.0.7"
+    },
+    "devDependencies": {
+        "@fullstackunicorn/cli": "^1.0.3",
+        "@fullstackunicorn/reduce": "^1.0.19"
+    }
+}