miolo 3.0.0-beta.21 → 3.0.0-beta.210

package/src/middleware/auth/passport/index.mjs

@@ -0,0 +1,374 @@
+import Router from "@koa/router"
+import passport from "koa-passport"
+import { Strategy as GoogleStrategy } from "passport-google-oauth20"
+import LocalStrategy from "passport-local"
+import { init_session_middleware } from "./session/index.mjs"
+
+// local: {
+//   get_user_id:     (user, done) => done(null, user.id), // default
+//   find_user_by_id: (id, done) => done(null, {id: 1}),  // ok=> done(null, user)  err=> done(error, null)
+//   local_auth_user: (username, password, done) => done(null, {id: 1})
+//                    // auth=> done(null, user) noauth=> done(null, false, {message: ''}) err=> done(error, null)
+//   local_url_login : '/login',
+//   local_url_logout: '/logout',
+//   local_url_login_redirect: undefined
+//   local_url_logout_redirect: '/'
+//   google_auth_user: (accessToken, refreshToken, profile, done, ctx) => done(null, {id: 1})
+//                    // auth=> done(null, user) noauth=> done(null, false, {message: ''}) err=> done(error, null)
+//   google_client_id: 'your-google-client-id',
+//   google_client_secret: 'your-google-client-secret',
+//   google_url_login : '/auth/google',
+//   google_url_callback : '/auth/google/callback',
+//   google_url_logout: '/logout',
+//   google_url_login_redirect: undefined
+//   google_url_logout_redirect: '/'
+// }
+
+const def_get_user_id = async (user, _ctx) => user?.id
+
+const def_find_user_by_id = async (_id, _ctx) => {
+  throw new Error("You need to define auth.passport.find_user_by_id")
+}
+
+const def_local_auth_user = async (_username, _password, _ctx) => {
+  throw new Error("You need to define auth.passport.local_auth_user")
+}
+
+const def_google_auth_user = async (_accessToken, _refreshToken, _profile, _ctx) => {
+  throw new Error("You need to define auth.passport.google_auth_user")
+}
+
+const init_passport_auth_middleware = (app, options, sessionConfig, cacheConfig) => {
+  const {
+    get_user_id,
+    find_user_by_id,
+    local_auth_user,
+    local_url_login,
+    local_url_logout,
+    local_url_login_redirect,
+    local_url_logout_redirect,
+    google_auth_user,
+    google_client_id,
+    google_client_secret,
+    google_url_login,
+    google_url_callback,
+    google_url_logout,
+    google_url_login_redirect,
+    google_url_logout_redirect
+  } = options
+
+  //const local_options = {}
+
+  // fallback funcs
+  const get_user_id_f = get_user_id || def_get_user_id
+  const find_user_by_id_f = find_user_by_id || def_find_user_by_id
+  const local_auth_user_f = local_auth_user || def_local_auth_user
+  const local_url_login_f = local_url_login || "/login"
+  const local_url_logout_f = local_url_logout || "/logout"
+  const google_auth_user_f = google_auth_user || def_google_auth_user
+
+  const google_url_login_f = google_url_login || "/auth/google"
+  const google_url_callback_f = google_url_callback || "/auth/google/callback"
+  const google_url_logout_f = google_url_logout || "/logout"
+
+  // init passport
+  const serialize_user = (ctx) => (user, done) => {
+    process.nextTick(() => {
+      try {
+        ctx.miolo.logger.debug(`[auth][passport] serializing user...`)
+        ctx.sessionId = ctx.session?.externalKey
+          ? ctx.getSessionStoreKey(ctx.session?.externalKey)
+          : undefined
+        get_user_id_f(user, ctx).then((uid) => {
+          return done(null, uid || false)
+        })
+      } catch (error) {
+        const msg = `Error serializing user: ${error}`
+        ctx.miolo.logger.error(`[auth][passport] ${msg}`)
+        return done(null, false, { message: msg })
+      }
+    })
+  }
+
+  const deserialize_user = (ctx) => (id, done) => {
+    process.nextTick(() => {
+      try {
+        ctx.miolo.logger.debug(`[auth][passport] deserializing user...`)
+        ctx.sessionId = ctx.session?.externalKey
+          ? ctx.getSessionStoreKey(ctx.session?.externalKey)
+          : undefined
+        find_user_by_id_f(id, ctx).then((user) => {
+          return done(null, user || false)
+        })
+      } catch (error) {
+        const msg = `Error deserializing user: ${error}`
+        ctx.miolo.logger.error(`[auth][passport] ${msg}`)
+        return done(null, false, { message: msg })
+      }
+    })
+  }
+
+  const local_strategy = (ctx) =>
+    new LocalStrategy.Strategy((username, password, done) => {
+      ctx.sessionId = ctx.session?.externalKey
+        ? ctx.getSessionStoreKey(ctx.session?.externalKey)
+        : undefined
+      try {
+        local_auth_user_f(username, password, ctx).then(([user, msg]) => {
+          ctx.body = {
+            authenticated: user || false,
+            message: msg,
+            user: user,
+            config: {
+              auth_method: "local"
+            }
+          }
+          return done(null, user || false, { message: msg || "" })
+        })
+      } catch (error) {
+        const msg = `Error local auth user: ${error}`
+        ctx.miolo.logger.error(`[auth][passport] ${msg}`)
+        return done(null, false, { message: msg })
+      }
+    })
+
+  let google_strategy
+
+  if (google_client_id) {
+    google_strategy = (ctx) =>
+      new GoogleStrategy(
+        {
+          clientID: google_client_id,
+          clientSecret: google_client_secret,
+          callbackURL: google_url_callback_f,
+          passReqToCallback: true,
+          proxy: process.env.NODE_ENV === "production"
+        },
+        (_req, accessToken, refreshToken, profile, done) => {
+          ctx.sessionId = ctx.session?.externalKey
+            ? ctx.getSessionStoreKey(ctx.session?.externalKey)
+            : undefined
+          try {
+            google_auth_user_f(accessToken, refreshToken, profile, ctx).then(([user, msg]) => {
+              ctx.body = {
+                authenticated: user || false,
+                message: msg,
+                user: user,
+                config: {
+                  auth_method: "google"
+                }
+              }
+              return done(null, user || false, { message: msg || "" })
+            })
+          } catch (error) {
+            const msg = `Error google auth user: ${error}`
+            ctx.miolo.logger.error(`[auth][passport] ${msg}`)
+            return done(null, false, { message: msg })
+          }
+        }
+      )
+  }
+
+  app.use((ctx, next) => {
+    passport.serializeUser(serialize_user(ctx))
+    passport.deserializeUser(deserialize_user(ctx))
+    passport.use(local_strategy(ctx))
+    if (google_client_id) {
+      passport.use("google", google_strategy(ctx))
+    }
+    return next()
+  })
+
+  init_session_middleware(app, sessionConfig, cacheConfig)
+
+  app.use(passport.initialize())
+  app.use(passport.session())
+
+  async function _ensure_ctx_user(ctx, next) {
+    try {
+      if (ctx.session.authenticated) {
+        ctx.session.user = ctx.state.user
+      }
+    } catch (_) {}
+    await next()
+  }
+  app.use(_ensure_ctx_user)
+
+  // handle auth routes
+  const handleLocalLogIn = (ctx, _next) => {
+    ctx.miolo.logger.debug(`[auth][local] handleLocalLogIn() - authenticating...`)
+    return passport.authenticate("local", async (err, user, info, _status) => {
+      const noUser = user === false || user === undefined || user === null
+      const hasErr = err !== undefined && err !== null
+      if (noUser || hasErr) {
+        ctx.miolo.logger.debug(`[auth][local] handleLocalLogIn() - user not authenticated`)
+        ctx.session.user = undefined
+        ctx.session.authenticated = false
+        ctx.session.auth_method = undefined
+        ctx.sessionId = undefined
+
+        // This will show error logs on the catcher middleware
+        // ctx.throw(401)
+
+        ctx.status = 401
+
+        ctx.body = {
+          ok: false,
+          data: {
+            user: undefined,
+            authenticated: false,
+            info: info
+          },
+          error: err?.message || err?.stack || err
+        }
+      } else {
+        ctx.miolo.logger.debug(`[auth][local] handleLocalLogIn() - user authenticated`)
+        await ctx.login(user)
+        ctx.session.user = user // ctx.state.user
+        ctx.session.authenticated = true
+        ctx.session.auth_method = "local"
+
+        ctx.body = {
+          ok: true,
+          data: {
+            user: user,
+            authenticated: true,
+            config: {
+              auth_method: "local"
+            }
+          }
+        }
+
+        if (local_url_login_redirect !== undefined) {
+          ctx.redirect(local_url_login_redirect)
+        }
+      }
+    })(ctx)
+  }
+
+  // handle auth routes
+  const handleGoogleLogin = (ctx, next) => {
+    ctx.miolo.logger.debug(`[auth][google] handleGoogleLogin() - authenticating...`)
+
+    const redirectUrl = ctx.query.redirect || "/"
+
+    ctx.miolo.logger.info(
+      `[auth][google] handleGoogleLogin() - authenticating with redirectUrl: ${redirectUrl}`
+    )
+
+    const strategy = passport.authenticate("google", {
+      scope: ["profile", "email"],
+      state: redirectUrl
+    })
+
+    return strategy(ctx, next)
+  }
+
+  const handleGoogleCallback = (ctx, next) => {
+    ctx.miolo.logger.debug(`[auth][google] handleGoogleCallback() - authenticating...`)
+    return passport.authenticate("google", async (err, user, info, _status) => {
+      if (err || user === false) {
+        ctx.miolo.logger.debug(`[auth][google] handleGoogleCallback() - user not authenticated`)
+        ctx.session.user = undefined
+        ctx.session.authenticated = false
+        ctx.session.auth_method = undefined
+        ctx.sessionId = undefined
+
+        // This will show error logs on the catcher middleware
+        // ctx.throw(401)
+
+        ctx.status = 401
+
+        ctx.body = {
+          ok: err === undefined,
+          data: {
+            user: undefined,
+            authenticated: false,
+            info: info
+          },
+          error: err
+        }
+
+        ctx.redirect(google_url_logout_redirect || "/")
+      } else {
+        ctx.miolo.logger.debug(`[auth][google] handleGoogleCallback() - user authenticated`)
+        await ctx.login(user)
+        ctx.session.user = user // ctx.state.user
+        ctx.session.authenticated = true
+        ctx.session.auth_method = "google"
+
+        // ctx.body = {
+        //   ok: true,
+        //   data: {
+        //     user: user,
+        //     authenticated: true,
+        //     config: {
+        //       auth_method: "google"
+        //     }
+        //   }
+        // }
+
+        const redirectUrl = ctx.query.state || google_url_login_redirect || "/"
+
+        ctx.miolo.logger.info(
+          `[auth][google] handleGoogleCallback() - redirecting to: ${redirectUrl}. query.state: ${ctx.query.state}. google_url_login_redirect: ${google_url_login_redirect}`
+        )
+
+        ctx.redirect(redirectUrl)
+      }
+    })(ctx, next)
+  }
+
+  const handleLogOut = async (ctx, _next) => {
+    if (ctx.session.authenticated) {
+      ctx.miolo.logger.debug(`[auth][passport] handleLogOut() - logging out...`)
+
+      ctx.session.user = undefined
+      ctx.session.authenticated = false
+      ctx.session.auth_method = undefined
+      ctx.sessionId = undefined
+
+      ctx.body = {
+        ok: true,
+        data: {
+          user: undefined,
+          authenticated: false
+        }
+      }
+
+      if (local_url_logout_redirect !== undefined) {
+        ctx.redirect(local_url_logout_redirect)
+      } else {
+        await ctx.logout()
+      }
+    } else {
+      ctx.miolo.logger.debug(`[auth][passport] handleLogOut() - logging out (unauthed)...`)
+
+      // This will show error logs on the catcher middleware
+      // ctx.throw(401)
+
+      ctx.status = 401
+      ctx.body = {
+        ok: true,
+        data: {
+          user: undefined,
+          authenticated: false
+        }
+      }
+    }
+  }
+
+  // Init the router
+  const login_router = new Router()
+  login_router.post(local_url_login_f, handleLocalLogIn)
+  login_router.get(local_url_logout_f, handleLogOut)
+  login_router.post(local_url_logout_f, handleLogOut)
+  login_router.get(google_url_login_f, handleGoogleLogin)
+  login_router.get(google_url_callback_f, handleGoogleCallback)
+  login_router.get(google_url_logout_f, handleLogOut)
+  login_router.post(google_url_logout_f, handleLogOut)
+
+  app.use(login_router.routes())
+}
+
+export { init_passport_auth_middleware }

package/src/middleware/auth/passport/session/index.mjs

@@ -0,0 +1,43 @@
+import { createSession } from "koa-session"
+// import store_koa_redis from './store_koa_redis.mjs'
+import { init_session_cache_store } from "./store.mjs"
+
+/**
+ * Middleware for session
+ * @param ctx
+ * @param next
+ */
+function init_session_middleware(app, sessionConfig, cacheConfig) {
+  const store = init_session_cache_store(cacheConfig, app.context.miolo.logger)
+
+  app.keys = [sessionConfig.secret || "*secret*"]
+
+  const options = {
+    // store: store_koa_redis,
+    store,
+    ...(sessionConfig.options || {})
+  }
+
+  app.context.miolo.session = {
+    store,
+    options
+  }
+
+  app.use(createSession(options, app))
+
+  app.use(async (ctx, next) => {
+    ctx.getSessionStoreKey = (externalKey) => {
+      return store.getInnerKey(externalKey)
+    }
+    await next()
+  })
+
+  app.initSessionStore = async () => {
+    await store.initCache()
+  }
+  app.closeSessionStore = async () => {
+    await store.closeCache()
+  }
+}
+
+export { init_session_middleware }

package/src/middleware/auth/{credentials → passport}/session/store.mjs

@@ -1,5 +1,5 @@
-import {cacheiro} from 'cacheiro'
-import { miolo_cacher_options_for_session } from '../../../context/cache/options.mjs'
+import { cacheiro } from "cacheiro"
+import { miolo_cacher_options_for_session } from "../../../context/cache/options.mjs"
 
 class SessionStore {
   constructor(options, logger) {
@@ -8,52 +8,72 @@ class SessionStore {
     this._cache = undefined
   }
 
-  async init_cache() {
-    if (this._cache == undefined) {
+  async initCache() {
+    if (this._cache === undefined) {
       this.logger.silly(`[session-store] Initing store`)
       this._cache = await cacheiro(this.options)
     }
     return this._cache
   }
 
+  async closeCache() {
+    if (this._cache !== undefined) {
+      this.logger.silly(`[session-store] Closing store`)
+      try {
+        await this._cache.close()
+      } catch (error) {
+        this.logger.warn(error)
+      }
+    }
+  }
+
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: keep definition for koa-session store
   async get(key, maxAge, { rolling, ctx }) {
-    
-    const cache = await this.init_cache()
+    const cache = await this.initCache()
     const jvalue = await cache.getItem(key)
     try {
       const value = JSON.parse(jvalue)
       this.logger.silly(`[session-store] Get session for ${key}: ${JSON.stringify(value)}`)
       //console.log(`[session-store] Get session for ${key}: ${JSON.stringify(value)}`)
       return value
-    } catch(_) {
+    } catch (_) {
       this.logger.silly(`[session-store] No session for ${key}`)
       //console.log(`[session-store] No session for ${key}`)
       return undefined
     }
   }
 
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: keep definition for koa-session store
   async set(key, sess, maxAge, { rolling, changed, ctx }) {
     this.logger.silly(`[session-store] Set session for ${key}`)
-    const cache = await this.init_cache()
-    let svalue = undefined
+    const cache = await this.initCache()
+    let svalue
     try {
       svalue = JSON.stringify(sess)
-    } catch(_) {}
+    } catch (_) {}
 
     // Rely on miolo settings for ttl / maxAge
     await cache.setItem(key, svalue /*, maxAge*/)
   }
-  
-  async destroy(key, {ctx}) {
+
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: keep definition for koa-session store
+  async destroy(key, { ctx }) {
     this.logger.silly(`[session-store] Destroy session for ${key}`)
-    const cache = await this.init_cache()
+    const cache = await this.initCache()
     await cache.unsetItem(key)
   }
-}
 
+  getInnerKey(key) {
+    if (this._cache === undefined) {
+      this.logger.error("[session-store] Calling getInnerKey() before cache is inited")
+      return key
+    }
+    return this._cache.getInnerKey(key)
+  }
+}
 
 export function init_session_cache_store(cacheConfig, logger) {
-  const options = miolo_cacher_options_for_session({cache: cacheConfig}, logger)
+  const options = miolo_cacher_options_for_session({ cache: cacheConfig }, logger)
   const store = new SessionStore(options, logger)
   return store
 }

package/src/middleware/auth/passport/session/store_koa_redis.mjs

@@ -0,0 +1,3 @@
+import RedisStore from "koa-redis"
+
+export default new RedisStore()

package/src/middleware/context/cache/index.mjs

@@ -1,61 +1,106 @@
-import { cacheiro } from 'cacheiro'
-import { miolo_cacher_options_for_custom } from './options.mjs'
+import { cacheiro } from "cacheiro"
+import { miolo_cacher_options_for_custom, miolo_cacher_options_for_fly } from "./options.mjs"
 
-let _glob_cache_stores = undefined
+let _glob_cache_mother
+const _local_cache_instances = new Map()
+
+const _get_cache_mother = async (config, logger) => {
+  if (_glob_cache_mother === undefined) {
+    const default_options = miolo_cacher_options_for_fly(
+      config,
+      {
+        type: process.env.MIOLO_CACHE_TYPE || "combined",
+        namespace: "miolo-cache-mother"
+      },
+      logger
+    )
+
+    _glob_cache_mother = await cacheiro(default_options)
+  }
+  return _glob_cache_mother
+}
 
 export function init_context_cache(config, logger) {
-  
-  const _init_cache_stores = async () => {
-    if (_glob_cache_stores==undefined) {
-      _glob_cache_stores = {}
-      const custom_options = miolo_cacher_options_for_custom(config, logger)
-      
-      for(const [name, options] of Object.entries(custom_options)) {
-        const cache_store = await cacheiro(options)
-        _glob_cache_stores[name] = cache_store
-      }
-          
-    }
-    return _glob_cache_stores
+  const custom_options = miolo_cacher_options_for_custom(config, logger)
+
+  const _init_cache_instance = async (name) => {
+    const cache_mother = await _get_cache_mother(config, logger)
+
+    const cache_instance = await cacheiro(custom_options?.[name] || {})
+    await cache_mother.setItem(name, "1")
+    _local_cache_instances.set(name, cache_instance)
+    return cache_instance
   }
 
+  const init = async () => {
+    await _get_cache_mother(config, logger)
+  }
 
   const get_cache = async (name) => {
-    const cache_stores = await _init_cache_stores()
-    return cache_stores[name]
+    if (_local_cache_instances.has(name)) {
+      return _local_cache_instances.get(name)
+    }
+
+    const cache_mother = await _get_cache_mother(config, logger)
+
+    const exists_in_mother = await cache_mother.getItem(name)
+    if (exists_in_mother) {
+      const cache_instance = await cacheiro(custom_options?.[name] || {})
+      _local_cache_instances.set(name, cache_instance)
+      return cache_instance
+    }
+
+    return await _init_cache_instance(name)
   }
-  const get_cache_names = async () => {
-    const cache_stores = await _init_cache_stores()
-    return Object.keys(cache_stores)
+
+  const get_cache_names = async (pattern = "*") => {
+    const cache_mother = await _get_cache_mother(config, logger)
+
+    return await cache_mother.getKeys(pattern)
   }
 
-  const drop_cache = async (name, clean) => {
-    const cache_stores = await _init_cache_stores()
+  const drop_cache = async (name, clean = true) => {
     if (clean) {
       const cache = await get_cache(name)
-      cache.unsetAll()
+      if (cache) {
+        try {
+          await cache.close()
+        } catch (error) {
+          logger.warn(error)
+        }
+      }
     }
-    delete cache_stores[name]
+    _local_cache_instances.delete(name)
+
+    const cache_mother = await _get_cache_mother(config, logger)
+    await cache_mother.unsetItem(name)
   }
 
-  const drop_caches = async (clean) => {
+  const close = async (clean = true) => {
+    const cache_mother = await _get_cache_mother(config, logger)
+
     if (clean) {
-      const cache_stores = await _init_cache_stores()
-      for(const [_name, cache] of Object.entries(cache_stores)) {
-        await cache.unsetAll()
+      for (const cache of _local_cache_instances.values()) {
+        try {
+          await cache.close()
+        } catch (error) {
+          logger.warn(error)
+        }
       }
     }
-    
-    _glob_cache_stores = {}
+    _local_cache_instances.clear()
+
+    await cache_mother.close()
+    _glob_cache_mother = undefined
   }
 
   const cache_ctx = {
+    init,
     get_cache,
     get_cache_names,
     drop_cache,
-    drop_caches
+    close
   }
 
   return cache_ctx
-
 }