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

package/template/src/server/io/db/users/auth.mjs

@@ -0,0 +1,132 @@
+import { intre_now } from "intre"
+import { sha512 } from "#server/utils/crypt.mjs"
+
+const _USER_LAST_CONN_DELAY = 5 * 1000
+let _USER_LAST_CONN_UPDATE = 0
+const _should_update_user_last_conn = () => {
+  const now = Math.floor(Date.now() / 1000)
+  if (_USER_LAST_CONN_UPDATE + _USER_LAST_CONN_DELAY < now) {
+    _USER_LAST_CONN_UPDATE = now
+    return true
+  }
+  return false
+}
+
+export async function db_find_user_by_id(miolo, uid) {
+  miolo.logger.silly(`[db_find_user_by_id] uid: ${uid}`)
+
+  const conn = await miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  const query = `
+    SELECT id, username, name, email, active, google_id, google_picture, 
+           last_login_date, last_login_ip, login_count, last_conn_at, created_at, last_update_at
+      FROM account
+     WHERE id = $1`
+
+  const data = await conn.select(query, [uid], options)
+
+  if (data.length === 0) {
+    return undefined
+  }
+
+  let user
+
+  try {
+    user = data[0]
+
+    if (_should_update_user_last_conn()) {
+      miolo.logger.silly(`[db_find_user_by_id] Updating ${user.name} last conn`)
+      const qupd = "UPDATE account SET last_conn_at = $1 WHERE id = $2"
+      conn.execute(qupd, [intre_now(), uid])
+    }
+  } catch (e) {
+    miolo.logger.error(`[db_find_user_by_id] Error ${e}`)
+  }
+
+  miolo.logger.silly(`[db_find_user_by_id] Found ${user.username}`)
+
+  return user
+}
+
+export async function db_auth_user(miolo, username, password) {
+  miolo.logger.debug(`[db_auth_user] authing: ${username}`)
+
+  const conn = await miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  let data
+  let msg = "Credenciales incorrectas"
+
+  const query = `
+    SELECT id, password
+      FROM account
+     WHERE username = $1`
+
+  const ruser = await conn.selectOne(query, [username], options)
+
+  if (ruser?.id === undefined) {
+    msg = "Usuario inexistente"
+  } else {
+    if (ruser?.password !== sha512(password, process.env.MIOLO_SESSION_SALT)) {
+      msg = "Contraseña incorrecta"
+    } else if (!Number.isNaN(ruser?.id)) {
+      data = await db_find_user_by_id(miolo, ruser.id)
+      msg = undefined
+
+      // update last conn
+      miolo.logger.silly(`[db_auth_user] updating ${username} last* fields`)
+      const ip = ""
+      const log_count = data?.login_count || 0
+      const qupd =
+        "UPDATE account SET last_conn_at = $1, last_login_date = $1, last_login_ip = $2, login_count = $3 WHERE id = $4"
+      conn.execute(qupd, [intre_now(), ip, log_count + 1, ruser.id])
+    }
+  }
+
+  miolo.logger.debug(`[db_auth_user] authing: ${username} => ${msg || "ok"}`)
+
+  return [data, msg]
+}
+
+export async function db_user_find_or_create_from_google(
+  miolo,
+  email,
+  name,
+  google_id,
+  google_picture
+) {
+  miolo.logger.debug(`[db_user_find_or_create_from_google] checking: ${email}`)
+  const conn = await miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  const query = `
+    SELECT id, username, name, email, active, google_id, google_picture, 
+           last_login_date, last_login_ip, login_count, last_conn_at, created_at, last_update_at
+      FROM account
+     WHERE google_id = $1`
+
+  const ruser = await conn.selectOne(query, [google_id], options)
+
+  if (ruser?.id === undefined) {
+    miolo.logger.debug(`[db_user_find_or_create_from_google] user ${email} not found, creating`)
+    const UUser = await conn.get_model("account")
+
+    const data = {
+      name,
+      email,
+      google_id,
+      google_picture,
+      active: 1
+    }
+    const uid = await UUser.insert(data, options)
+    data.id = uid
+    return [data, undefined]
+  } else {
+    miolo.logger.debug(`[db_user_find_or_create_from_google] user ${email} found, returning`)
+    return [ruser, undefined]
+  }
+}

package/template/src/server/io/db/users/pwd.mjs

@@ -0,0 +1,38 @@
+import { sha512 } from "#server/utils/crypt.mjs"
+
+export async function db_password_change(miolo, email, passwords) {
+  const conn = await miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  let ok = false
+  let msg = "Credenciales incorrectas"
+
+  let query = `
+    SELECT id, password
+      FROM account
+     WHERE username = $1 OR email = $1`
+
+  const data = await conn.selectOne(query, [email], options)
+
+  if (Number.isNaN(data?.id)) {
+    msg = "Usuario inexistente"
+  } else {
+    if (data?.password !== sha512(passwords.current, process.env.MIOLO_SESSION_SALT)) {
+      msg = "Contraseña actual incorrecta"
+    } else {
+      try {
+        query = "UPDATE account SET password = $1 WHERE id = $2"
+        const pwd = sha512(passwords.new, process.env.MIOLO_SESSION_SALT)
+        await conn.execute(query, [pwd, data.id])
+
+        msg = "Contraseña modificada correctamente"
+        ok = true
+      } catch (err) {
+        msg = `Error al modificar la contraseña: ${err}`
+      }
+    }
+  }
+
+  return { ok, msg }
+}

package/template/src/server/io/db/users/save.mjs

@@ -0,0 +1,17 @@
+export async function db_user_save(miolo, data) {
+  const conn = await miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  const uid = data.id
+  const User = await conn.get_model("account")
+
+  let nuid = uid
+  if (uid === undefined) {
+    nuid = await User.insert(data, options)
+  } else {
+    data.email = data.username
+    await User.update(data, { id: uid }, options)
+  }
+  return nuid
+}

package/template/src/server/miolo/auth/basic.mjs

@@ -0,0 +1,15 @@
+import { db_auth_user } from "#server/io/db/users/auth.mjs"
+
+const local_auth_user = async (username, password, ctx) => {
+  const [user, msg] = await db_auth_user(ctx.miolo, username, password)
+
+  return [user, msg]
+}
+
+export default {
+  basic: {
+    auth_user: local_auth_user,
+    realm: undefined, //'demo.app',
+    paths: ["/crud"] // ['/api']
+  }
+}

package/template/src/server/miolo/auth/guest.mjs

@@ -0,0 +1,3 @@
+export default {
+  guest: {}
+}

package/template/src/server/miolo/auth/passport.mjs

@@ -0,0 +1,73 @@
+import {
+  db_auth_user,
+  db_find_user_by_id,
+  db_user_find_or_create_from_google
+} from "#server/io/db/users/auth.mjs"
+
+const get_user_id = async (user, ctx) => {
+  ctx.miolo.logger.debug(
+    `[auth][local] get_user_id() - name ${user?.name} - sessionId ${ctx.sessionId}`
+  )
+  return user?.id
+}
+
+const find_user_by_id = async (id, ctx) => {
+  ctx.miolo.logger.debug(
+    `[auth][local] find_user_by_id() - Searching user id ${id} - sessionId ${ctx.sessionId}`
+  )
+  const user = await db_find_user_by_id(ctx.miolo, id)
+  return user
+}
+
+const local_auth_user = async (username, password, ctx) => {
+  ctx.miolo.logger.debug(
+    `[auth][local] local_auth_user() - checking credentials for ${username} - sessionId ${ctx.sessionId}`
+  )
+
+  const [user, msg] = await db_auth_user(ctx.miolo, username, password)
+  return [user, msg]
+}
+
+const google_auth_user = async (_accessToken, _refreshToken, profile, ctx) => {
+  try {
+    // Extract Google profile info
+    const google_id = profile.id
+    const email = profile.emails?.[0]?.value
+    const name = profile.displayName
+    const google_picture = profile.photos?.[0]?.value
+
+    ctx.miolo.logger.info(`[auth][google] Authenticated user: ${email}`)
+    ctx.miolo.logger.debug(
+      `[auth][google] google_auth_user() - upsaving db user for ${email} - sessionId ${ctx.sessionId}`
+    )
+
+    const [user, msg] = await db_user_find_or_create_from_google(
+      ctx.miolo,
+      email,
+      name,
+      google_id,
+      google_picture
+    )
+    return [user, msg]
+  } catch (error) {
+    ctx.miolo.logger.error(`[auth][google] Error preparing db user: ${error}`)
+    return [undefined, error]
+  }
+}
+
+export default {
+  get_user_id,
+  find_user_by_id,
+  local_auth_user,
+  local_url_login: "/login",
+  local_url_logout: "/logout",
+  local_url_login_redirect: undefined,
+  local_url_logout_redirect: "/",
+  google_auth_user,
+  google_client_id: process.env.MIOLO_AUTH_GOOGLE_CLIENT_ID,
+  google_client_secret: process.env.MIOLO_AUTH_GOOGLE_CLIENT_SECRET,
+  google_url_login: "/auth/google",
+  google_url_callback: process.env.MIOLO_AUTH_GOOGLE_CALLBACK_URL || "/auth/google/callback",
+  google_url_logout: "/logout",
+  google_url_logout_redirect: "/"
+}

package/template/src/server/miolo/cache.mjs

@@ -0,0 +1,11 @@
+export default {
+  default: {
+    type: "redis",
+    redis: {
+      host: process.env.IS_DOCKER === "true" ? "redis" : "127.0.0.1",
+      port: 6379
+    },
+    version: 2,
+    clean: false
+  }
+}

package/template/src/server/miolo/cron/foo.mjs

@@ -0,0 +1,7 @@
+import { blue } from "tinguir"
+
+export const onTickFoo = async (miolo) => {
+  miolo.logger.info(`${blue("[cron][foo]")} Fooing...`)
+
+  miolo.logger.info(`${blue("[cron][foo]")} Foo done!`)
+}

package/template/src/server/miolo/cron/index.mjs

@@ -0,0 +1,28 @@
+import { onTickFoo } from "./foo.mjs"
+import { cacheInvalidate } from "./invalidate.mjs"
+
+// check https://github.com/kelektiv/node-cron#readme
+//
+// https://crontab.guru/
+
+export default function init_cron() {
+  const cronList = []
+
+  cronList.push({
+    name: "miolo-sample-foo",
+    cronTime: "*/30 * * * *",
+    onTick: onTickFoo,
+    start: true
+  })
+
+  cronList.push({
+    name: "miolo-sample-cache-invalidate",
+    cronTime: "*/1 * * * *",
+    onTick: cacheInvalidate,
+    start: true
+  })
+
+  console.log(`[miolo-sample][cron] ${cronList.length} custom cron jobs loaded`)
+
+  return cronList
+}

package/template/src/server/miolo/cron/invalidate.mjs

@@ -0,0 +1,21 @@
+import { intre_now, intre_to_str } from "intre"
+import { blue } from "tinguir"
+import { db_todo_upsave } from "#server/io/db/todos/upsave.mjs"
+
+export const cacheInvalidate = async (miolo) => {
+  miolo.logger.info(`${blue("[cron][cache_invalidate]")} Invalidating cache...`)
+
+  // broadcast an event to all clients
+  //miolo.io.emit("ssr-invalidate", { name: "todos" })
+
+  const ctx = { miolo }
+
+  await db_todo_upsave(ctx, {
+    description: `${intre_to_str(intre_now(), "DD/MM/YYYY HH:mm:ss")} - auto todo`,
+    done: false
+  })
+
+  miolo.io.emit("ssr-refresh", { name: "todos" })
+
+  miolo.logger.info(`${blue("[cron][cache_invalidate]")} Cache invalidated!`)
+}

package/template/src/server/miolo/db.mjs

@@ -0,0 +1,36 @@
+// import path from 'path'
+// import {fileURLToPath} from 'url'
+import { beforeInsertUser } from "#server/io/db/triggers/user.mjs"
+
+// const __filename = fileURLToPath(import.meta.url)
+// const __dirname = path.dirname(__filename)
+
+// Only for CRUD routes!
+const useUserFields = {
+  use: true,
+  fieldNames: {
+    created_by: "created_by",
+    last_update_by: "last_update_by"
+  }
+}
+
+const TABLES = [
+  {
+    name: "account",
+    useDateFields: true,
+    triggers: {
+      beforeInsert: beforeInsertUser
+    }
+  },
+  {
+    name: "todo",
+    useDateFields: true,
+    useUserFields
+  }
+]
+
+export default {
+  options: {
+    tables: TABLES
+  }
+}

package/template/src/server/miolo/http.mjs

@@ -0,0 +1,14 @@
+import path from "node:path"
+
+const root = (dir) => path.resolve(process.cwd(), dir)
+
+export default {
+  static: {
+    favicon: root("src/static/img/favicon.ico"),
+    folders: {
+      "/build": root("build"),
+      "/static": root("src/static"),
+      "/": root("src/static/public")
+    }
+  }
+}

package/template/src/server/miolo/index.mjs

@@ -0,0 +1,43 @@
+import passport from "./auth/passport.mjs"
+import cache from "./cache.mjs"
+import init_cron from "./cron/index.mjs"
+import db from "./db.mjs"
+import http from "./http.mjs"
+import routes from "./routes/index.mjs"
+import { loader } from "./ssr/loader.mjs"
+
+export default () => {
+  return {
+    name: "miolo-sample",
+    http,
+    auth: {
+      passport
+    },
+    db,
+    routes,
+    cache,
+    build: {
+      ssr: { loader }
+    },
+    cron: init_cron(),
+    socket: {
+      enabled: true,
+      namespaces: [
+        {
+          name: "todos-update",
+          listener: (data) => {
+            console.log("TODOS UPDATED!!!")
+            console.log(data)
+          }
+        },
+        {
+          name: "ping",
+          listener: (data) => {
+            console.log("PING!!!")
+            console.log(data)
+          }
+        }
+      ]
+    }
+  }
+}

package/template/src/server/miolo/routes/crud.mjs

@@ -0,0 +1,16 @@
+export default [
+  {
+    prefix: "/crud",
+    auth: {
+      require: true,
+      action: "redirect",
+      redirect_url: "/login"
+    },
+    routes: [
+      {
+        name: "todo",
+        mode: "rw"
+      }
+    ]
+  }
+]

package/template/src/server/miolo/routes/index.mjs

@@ -0,0 +1,8 @@
+import queries from "#server/routes/index.mjs"
+import crud from "./crud.mjs"
+
+export default {
+  bodyField: undefined,
+  crud: crud,
+  queries: queries
+}

package/template/src/server/miolo/ssr/entry-server.jsx

@@ -0,0 +1,13 @@
+import { AppServer } from "miolo-react"
+import { renderToString } from "react-dom/server"
+import { StaticRouter } from "react-router"
+import App from "../../../cli/App.jsx"
+
+export const render = (ctx, context) =>
+  renderToString(
+    <AppServer context={context}>
+      <StaticRouter location={ctx.url}>
+        <App />
+      </StaticRouter>
+    </AppServer>
+  )

package/template/src/server/miolo/ssr/loader.mjs

@@ -0,0 +1,18 @@
+import { db_todo_read } from "#server/io/db/todos/read.mjs"
+
+const loader = async (ctx) => {
+  let lastTodos = []
+
+  try {
+    lastTodos = await db_todo_read(ctx, { options: { limit: 3 } })
+    lastTodos = lastTodos.sort((a, b) => b.created_at - a.created_at)
+  } catch (_) {}
+
+  const data = {
+    lastTodos
+  }
+
+  return data
+}
+
+export { loader }

package/template/src/server/routes/index.mjs

@@ -0,0 +1,66 @@
+import Joi from "joi"
+import { with_miolo_input_schema, with_miolo_output_schema } from "miolo"
+import { r_todo_delete, r_todo_toggle_done, r_todo_upsave } from "./todos/mod.mjs"
+
+import { r_todo_find, r_todo_last, r_todo_list } from "./todos/read.mjs"
+import { r_todo_count_last_hours, r_todo_insert_fake } from "./todos/special.mjs"
+import { r_change_password, r_forgot, r_user_save } from "./users/user.mjs"
+
+const auth = {
+  require: true,
+  action: "redirect",
+  redirect_url: "/page/login"
+}
+
+export default [
+  {
+    prefix: "api",
+    routes: [
+      { method: "POST", url: "/user/forgot", callback: r_forgot },
+      { method: "POST", url: "/user/chpwd", auth, callback: r_change_password },
+      { method: "POST", url: "/user/save", auth, callback: r_user_save },
+
+      { method: "GET", url: "/todo/list", auth, callback: r_todo_list },
+      { method: "GET", url: "/todo/last", auth, callback: r_todo_last },
+      { method: "GET", url: "/todo/findone", auth, callback: r_todo_find },
+      { method: "POST", url: "/todo/upsave", auth, callback: r_todo_upsave },
+      { method: "POST", url: "/todo/delete", auth, callback: r_todo_delete },
+      { method: "POST", url: "/todo/toggle", auth, callback: r_todo_toggle_done },
+
+      {
+        url: "/todo/last_hours",
+        method: "GET",
+        // Passing schema on the route definition
+        callback: r_todo_count_last_hours,
+        schema: {
+          input: Joi.object({
+            hours: Joi.number().min(1).max(24)
+          }),
+          output: Joi.object({
+            count: Joi.number()
+          })
+        }
+      },
+      {
+        url: "/todo/fake",
+        method: "POST",
+        // Wrapping function with the schema
+        callback: with_miolo_output_schema(
+          with_miolo_input_schema(
+            r_todo_insert_fake,
+            Joi.object({
+              done: Joi.bool().optional().default(false)
+            })
+          ),
+          Joi.object({
+            ok: Joi.bool(),
+            data: Joi.object({
+              id: Joi.number()
+            })
+          })
+        ),
+        auth
+      }
+    ]
+  }
+]

package/template/src/server/routes/todos/mod.mjs

@@ -0,0 +1,52 @@
+import { db_todo_delete } from "#server/io/db/todos/delete.mjs"
+import { db_todo_toggle } from "#server/io/db/todos/toggle.mjs"
+import { db_todo_upsave } from "#server/io/db/todos/upsave.mjs"
+
+export async function r_todo_upsave(ctx, params) {
+  try {
+    ctx.miolo.logger.info(
+      `[r_todo_upsave] Upsaving todo info for tid ${params?.id || "new"} -> ${params?.description}`
+    )
+
+    const res = await db_todo_upsave(ctx, params)
+
+    ctx.miolo.logger.info(`[r_todo_upsave] Upsaved todo info for tid ${params?.id || "new"}`)
+    return { ok: true, data: res }
+  } catch (error) {
+    ctx.miolo.logger.error(
+      `[r_todo_upsave] Error upsaving todo info for tid ${params?.id || "new"}: ${error}`
+    )
+    return { ok: false, error: error?.message }
+  }
+}
+
+export async function r_todo_delete(ctx, params) {
+  try {
+    ctx.miolo.logger.info(`[r_todo_delete] Deleting todo info for tid ${params?.id}`)
+
+    const res = await db_todo_delete(ctx, params)
+
+    ctx.miolo.logger.info(`[r_todo_delete] Deleted todo for tid ${params.id}`)
+    return { ok: true, data: res }
+  } catch (error) {
+    ctx.miolo.logger.error(`[r_todo_delete] Error deleting todo for tid ${params?.id}: ${error}`)
+    return { ok: false, error: error?.message }
+  }
+}
+
+export async function r_todo_toggle_done(ctx, params) {
+  try {
+    ctx.miolo.logger.info(`[r_todo_toggle_done] Toggling todo with id ${params?.id}`)
+
+    const done = await db_todo_toggle(ctx, params)
+
+    ctx.miolo.logger.info(`[r_todo_toggle_done] Toggled todo with tid ${params?.id}`)
+
+    return { ok: true, data: { done } }
+  } catch (error) {
+    ctx.miolo.logger.error(
+      `[r_todo_toggle_done] Error toggling todo with tid ${params?.id}: ${error}`
+    )
+    return { ok: false, error: error?.message }
+  }
+}

package/template/src/server/routes/todos/read.mjs

@@ -0,0 +1,45 @@
+import { db_todo_find } from "#server/io/db/todos/find.mjs"
+import { db_todo_read } from "#server/io/db/todos/read.mjs"
+
+export async function r_todo_list(ctx, _params) {
+  try {
+    ctx.miolo.logger.info(`[r_todo_list] Reading todo list`)
+
+    const res = await db_todo_read(ctx, { filter: {}, options: {} })
+
+    ctx.miolo.logger.info(`[r_todo_list] Read todo list (${res.length})`)
+    return { ok: true, data: res }
+  } catch (error) {
+    ctx.miolo.logger.error(`[r_todo_list] Error reading todo list: ${error}`)
+    return { ok: false, error: error?.message }
+  }
+}
+
+// biome-ignore lint/correctness/noUnusedFunctionParameters: params is not used
+export async function r_todo_last(ctx, params) {
+  try {
+    ctx.miolo.logger.info(`[r_todo_last] Reading last todos`)
+
+    const res = await db_todo_read(ctx, { options: { limit: 3 } })
+
+    ctx.miolo.logger.info(`[r_todo_last] Read last todos (${res.length})`)
+    return { ok: true, data: res }
+  } catch (error) {
+    ctx.miolo.logger.error(`[r_todo_last] Error reading last todos: ${error}`)
+    return { ok: false, error: error?.message }
+  }
+}
+
+export async function r_todo_find(ctx, params) {
+  try {
+    ctx.miolo.logger.info(`[r_todo_find] Reading todo for tid ${params?.id}`)
+
+    const todo = await db_todo_find(ctx, { filter: { id: params?.id } })
+
+    ctx.miolo.logger.info(`[r_todo_find] Read todo for tid ${params?.id}`)
+    return { ok: todo?.id !== undefined, data: todo }
+  } catch (error) {
+    ctx.miolo.logger.error(`[r_todo_find] Error reading todo for tid ${params?.id}: ${error}`)
+    return { ok: false, error: error?.message }
+  }
+}