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

package/template/src/cli/pages/todos/context/TodosProvider.jsx

@@ -0,0 +1,191 @@
+import { useMioloContext } from "miolo-react"
+import { useCallback, useEffect, useState } from "react"
+import useSessionContext from "#cli/context/session/useSessionContext.mjs"
+import useUIContext from "#cli/context/ui/useUIContext.mjs"
+import TodoList from "#ns/models/TodoList.mjs"
+import TodosContext from "./TodosContext.jsx"
+
+const TodosProvider = ({ children }) => {
+  // const [status, setStatus] = useState("loaded")
+  const { logger } = useMioloContext()
+  const { useSsrData, fetcher, socket, authenticated } = useSessionContext()
+  const { toast } = useUIContext()
+  const [useCrud, setUseCrud] = useState(true)
+  const [socketInited, setSocketInited] = useState(false)
+
+  const {
+    data: todoList,
+    setData: setTodoList,
+    refresh: refreshTodoList,
+    ready,
+    invalidate: invalidateTodoList
+  } = useSsrData("todos", {
+    model: TodoList,
+    loader: useCallback(
+      async (_context, fetcher) => {
+        //setStatus("loading")
+        const res = useCrud ? await fetcher.read("/crud/todo") : await fetcher.get("/api/todo/list")
+
+        if (!res.ok) {
+          toast.error(`Error loading todos: ${res.error}`)
+        }
+        const data = res?.data || []
+        //setStatus("loaded")
+        return data.sort((a, b) => b.created_at - a.created_at)
+      },
+      [useCrud, toast]
+    ),
+    cache: true
+  })
+
+  const addTodo = useCallback(
+    (text) => {
+      async function addIt() {
+        const todoObject = {
+          id: undefined,
+          description: text,
+          done: false
+        }
+
+        const res = useCrud
+          ? await fetcher.upsave("crud/todo", todoObject)
+          : await fetcher.post("/api/todo/upsave", todoObject)
+
+        if (!res.ok) {
+          toast.error(`Error adding todo: ${res.error}`)
+        }
+
+        todoObject.id = useCrud ? res?.data : res?.data?.id
+
+        setTodoList([todoObject, ...todoList.getData()])
+      }
+
+      addIt()
+    },
+    [fetcher, todoList, setTodoList, useCrud, toast]
+  )
+
+  const toggleTodo = useCallback(
+    (todoId) => {
+      async function toggleIt() {
+        const nTodoList = [...todoList.getData()]
+        const selectedTodoIndex = nTodoList.findIndex((item) => item.id === todoId)
+        nTodoList[selectedTodoIndex].done = !nTodoList[selectedTodoIndex].done
+
+        setTodoList(nTodoList)
+
+        const res = useCrud
+          ? await fetcher.upsave("crud/todo", nTodoList[selectedTodoIndex])
+          : await fetcher.post("/api/todo/toggle", {
+              id: todoId,
+              done: nTodoList[selectedTodoIndex].done
+            })
+
+        if (!res.ok) {
+          toast.error(`Error toggling todo: ${res.error}`)
+        }
+      }
+
+      toggleIt()
+    },
+    [fetcher, todoList, setTodoList, useCrud, toast]
+  )
+
+  const removeTodo = useCallback(
+    async (todoId) => {
+      const nTodoList = [...todoList.getData()]
+      nTodoList.splice(
+        nTodoList.findIndex((item) => item.id === todoId),
+        1
+      )
+
+      setTodoList(nTodoList)
+
+      const res = useCrud
+        ? await fetcher.remove("crud/todo", todoId)
+        : await fetcher.post("api/todo/delete", { id: todoId })
+
+      if (!res.ok) {
+        toast.error(`Error removing todo: ${res.error}`)
+      } else {
+        toast.info(`Todo removed successfully`)
+      }
+    },
+    [fetcher, todoList, setTodoList, useCrud, toast]
+  )
+
+  const checkLastHours = useCallback(
+    async ({ hours }) => {
+      const res = await fetcher.get("api/todo/last_hours", { hours })
+      if (res.ok === true) {
+        toast.info(`You have added ${res?.data?.count} todos in the last ${hours} hours`)
+      } else {
+        toast.error(`Error checking last hours: ${res.error}`)
+      }
+    },
+    [fetcher, toast]
+  )
+
+  const insertFakeTodo = useCallback(async () => {
+    const res = await fetcher.post("api/todo/fake", { done: true })
+
+    if (!res.ok) {
+      toast.error(`Error adding fake todo: ${res.error}`)
+    } else {
+      toast.info(`Fake todo added with id ${res?.data?.id}`)
+    }
+    refreshTodoList()
+  }, [fetcher, refreshTodoList, toast])
+
+  const pingSocket = useCallback(() => {
+    if (!socket) {
+      toast.error("Socket not initialized")
+      return
+    }
+    socket.emit("ping", { timestamp: new Date().toISOString() })
+  }, [socket, toast])
+
+  useEffect(() => {
+    if (socket === undefined) {
+      return
+    }
+
+    if (socketInited) {
+      return
+    }
+    setSocketInited(true)
+
+    socket.on("connect", () => {
+      logger.info("Connected to server!")
+    })
+
+    socket.on("todos-update", (data) => {
+      logger.info("TODOS UPDATED!!!")
+      logger.info(data)
+    })
+  }, [socket, socketInited, logger])
+
+  return (
+    <TodosContext.Provider
+      value={{
+        todoList,
+        refreshTodoList,
+        loading: !ready,
+        loaded: ready,
+        addTodo,
+        toggleTodo,
+        removeTodo,
+        checkLastHours,
+        insertFakeTodo,
+        canEdit: authenticated,
+        useCrud,
+        setUseCrud,
+        pingSocket
+      }}
+    >
+      {children}
+    </TodosContext.Provider>
+  )
+}
+
+export default TodosProvider

package/template/src/cli/pages/todos/context/useTodosContext.mjs

@@ -0,0 +1,4 @@
+import { useContext } from "react"
+import TodosContext from "./TodosContext.jsx"
+
+export default () => useContext(TodosContext)

package/template/src/ns/models/Todo.mjs

@@ -0,0 +1,29 @@
+import { MioloModel } from "miolo-model"
+
+export default class Todo extends MioloModel {
+  get id() {
+    return this._get("id", null)
+  }
+  get description() {
+    return this._get("description", "")
+  }
+  get done() {
+    return this._get("done", false)
+  }
+  toggle() {
+    this._set("done", !this.done)
+  }
+
+  get createdAt() {
+    return this._get("created_at")
+  }
+  get lastUpdateAt() {
+    return this._get("last_update_at")
+  }
+  get createdBy() {
+    return this._get("created_by")
+  }
+  get lastUpdateBy() {
+    return this._get("last_update_by")
+  }
+}

package/template/src/ns/models/TodoList.mjs

@@ -0,0 +1,8 @@
+import { MioloArray } from "miolo-model"
+import Todo from "./Todo.mjs"
+
+export default class TodoList extends MioloArray {
+  constructor(items = []) {
+    super(Todo, items)
+  }
+}

package/template/src/ns/models/User.mjs

@@ -0,0 +1,40 @@
+import { MioloModel } from "miolo-model"
+
+export default class User extends MioloModel {
+  get id() {
+    return this._get("id")
+  }
+  get username() {
+    return this._get("username")
+  }
+  get password() {
+    return this._get("password")
+  }
+  get name() {
+    return this._get("name")
+  }
+  get email() {
+    return this._get("email")
+  }
+  get active() {
+    return this._get("active")
+  }
+  get lastLoginDate() {
+    return this._get("last_login_date")
+  }
+  get lastLoginIp() {
+    return this._get("last_login_ip")
+  }
+  get loginCount() {
+    return this._get("login_count")
+  }
+  get lastConnAt() {
+    return this._get("last_conn_at")
+  }
+  get createdAt() {
+    return this._get("created_at")
+  }
+  get lastUpdateAt() {
+    return this._get("last_update_at")
+  }
+}

package/template/src/server/bot/check_today.mjs

@@ -0,0 +1,10 @@
+import { intre_now, intre_pretty_long } from "intre"
+
+function check_today() {
+  const now = intre_now()
+  const today = intre_pretty_long(now)
+  console.log(`[miolo-sample][check_today] Today is ${today}`)
+  return today
+}
+
+check_today()

package/template/src/server/io/cache/base.mjs

@@ -0,0 +1,21 @@
+export async function cache_get_or_set_json(ctx, name, key, callback) {
+  const cache = await ctx.miolo.cache.get_cache(name)
+
+  if (!cache) {
+    ctx.miolo.logger.warn(`[cache] Cache ${name} is not ready!`)
+  }
+
+  if (cache) {
+    if (await cache.hasItem(key)) {
+      return JSON.parse(await cache.getItem(key))
+    }
+  }
+
+  const data = await callback()
+
+  if (cache) {
+    await cache.setItem(key, JSON.stringify(data))
+  }
+
+  return data
+}

package/template/src/server/io/db/filter.mjs

@@ -0,0 +1,92 @@
+/**
+ *
+ * @param {*} filter An object like
+ *   {field1: 10, field2: 'HEY', field3: [1, 2, 3], ...}
+ * @param {*} modifiers Optionally modify how fields will be filtered
+ *   {
+ *     <field_name>: {alias: '', coalesce: true|false|'', op: =|~*|...
+ *   }
+ *     alias: the alias in the query for that filter ('s.id', 'table.field1', ...)
+ *            <field_name> will be the default
+ *     coalesce: if you want to apply some COALESCE on the filter.
+ *               For example, if true, result of filter is:
+ *               ' AND COALESCE(<alias>, TRUE) IS <value> '
+ *     op: By default. the operator to use will be taken based on the value's type:
+ *         If array  : ' AND <alias> IN ($1:CSV) '
+ *         If boolean: ' AND <alias> IS TRUE/FALSE '
+ *         If others : ' AND <alias> = $1 '
+ *         You may need another one, for example: {op: '~*}:
+ *                     ' AND <alias> ~* $1 '
+ * @param {*} options Optional:
+ *     {
+ *       fields: ['field1', 'field2']
+ *               Only fields specified here will be taken from <filter>
+ *       startWithWhere: If true (default), returned `where` will be 'WHERE ...'.
+ *                       If false, it will start like 'AND ...'
+ *     }
+ *
+ * @returns
+ *   [where, values]
+ *
+ *
+ * @example
+ *   make_query_filter({'a': 10, 'b': [1,2,3], 'c': '11111', 'd': false}, {'d': {'alias': 'DEDO', 'coalesce': true}})
+ *     [
+ *        "  WHERE  a = $1  AND  b IN ($2:csv)   AND  c = $3  AND  COALESCE(DEDO, TRUE)  IS FALSE ",
+ *        [10, [1,2,3], '11111']
+ *     ]
+ *
+ */
+export const make_query_filter = (filter, modifiers = {}, options = {}) => {
+  let where = "",
+    values = []
+
+  if (filter) {
+    const startWithWhere = options?.startWithWhere !== false
+
+    let filter_fields = Object.keys(filter)
+    if (options?.fields) {
+      filter_fields = filter_fields.filter((f) => options.fields.indexOf(f) >= 0)
+    }
+
+    filter_fields.forEach((field_name) => {
+      const raw_value = filter[field_name]
+      if (raw_value === undefined || raw_value === null) {
+        return
+      }
+
+      const mod = modifiers[field_name] || {}
+
+      const prefix = values.length === 0 && startWithWhere ? " WHERE " : " AND "
+
+      const alias = mod?.alias || field_name
+      let filter_name = alias
+      if (mod?.coalesce) {
+        const def_value =
+          mod.coalesce === true ? "TRUE" : mod.coalesce === false ? "FALSE" : mod.coalesce
+        filter_name = `COALESCE(${alias}, ${def_value})`
+      }
+
+      const value = raw_value === "true" ? true : raw_value === "false" ? false : raw_value
+
+      let qfilter = ""
+
+      if (typeof value === "boolean") {
+        qfilter = `IS ${value === true ? "TRUE" : "FALSE"}`
+      } else {
+        if (Array.isArray(value)) {
+          qfilter = `IN ($${values.length + 1}:csv)`
+          values.push(value)
+        } else {
+          const op = mod?.op || "="
+          qfilter = `${op} $${values.length + 1}`
+          values.push(value)
+        }
+      }
+
+      where += ` ${prefix} ${filter_name} ${qfilter}`
+    })
+  }
+
+  return [where, values]
+}

package/template/src/server/io/db/todos/delete.mjs

@@ -0,0 +1,29 @@
+import Joi from "joi"
+import { with_miolo_input_schema } from "miolo"
+import { opt_int } from "#server/utils/schema.mjs"
+import { db_todo_find } from "./find.mjs"
+
+async function _db_todo_delete(ctx, params) {
+  ctx.miolo.logger.verbose(`[db_todo_delete] id: ${params?.id}`)
+
+  const conn = await ctx.miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  const Todo = await conn.get_model("todo")
+
+  const todo = await db_todo_find(ctx, params.id)
+
+  if (todo == null) {
+    throw new Error(`[db_todo_delete] Trying to delete a todo that does not exist`)
+  }
+
+  await Todo.delete({ id: params.id }, options)
+  return params.id
+}
+
+const todo_delete_schema = Joi.object({
+  id: opt_int
+})
+
+export const db_todo_delete = with_miolo_input_schema(_db_todo_delete, todo_delete_schema)

package/template/src/server/io/db/todos/find.mjs

@@ -0,0 +1,13 @@
+import { db_todo_read } from "./read.mjs"
+
+export async function db_todo_find(ctx, params) {
+  ctx.miolo.logger.verbose(`[db_todo_find] id: ${params?.filter?.id}`)
+
+  const todos = await db_todo_read(ctx, params)
+
+  if (todos.length === 0) {
+    return null
+  }
+
+  return todos[0]
+}

package/template/src/server/io/db/todos/read.mjs

@@ -0,0 +1,83 @@
+import Joi from "joi"
+import { with_miolo_input_schema } from "miolo"
+import { make_query_filter } from "#server/io/db/filter.mjs"
+import { bool_null, opt_int, opt_str_null } from "#server/utils/schema.mjs"
+
+/**
+ * filter: {
+ *    id / todo_id
+ *    description
+ *    done
+ * }
+ * options {
+ *    limit : optional int
+ * }
+ */
+async function _db_todo_read(ctx, { filter, options }) {
+  try {
+    ctx.miolo.logger.verbose(
+      `[db_todo_read] Reading todos with filter: ${JSON.stringify(filter)} and options ${JSON.stringify(options)}`
+    )
+
+    const conn = await ctx.miolo.db.get_connection()
+
+    let query = `
+      SELECT *
+        FROM todo AS t
+        *WHERE*`
+
+    if (options?.limit !== undefined) {
+      query += ` LIMIT ${options.limit}`
+    }
+
+    const [where, values] = make_query_filter(
+      filter,
+      {
+        todo_id: { alias: "t.id" },
+        description: { op: "~*" },
+        done: { coalesce: false, alias: "COALESCE(done, false)" }
+      },
+      {
+        fields: ["id", "todo_id", "description", "done"]
+      }
+    )
+
+    query = query.replace("*WHERE*", where)
+
+    // if (values.length == 0){
+    //   ctx.miolo.logger.warn(`[prop_detail] Some filter must be specified`)
+    //   return []
+    // }
+
+    const todos = await conn.select(query, values)
+
+    ctx.miolo.logger.verbose(`[db_todo_read] Read ${todos.length} todos`)
+
+    return todos
+  } catch (error) {
+    ctx.miolo.logger.error(`[db_todo_read] Error reading todos: ${error}`)
+    return []
+  }
+}
+
+/**
+ * filter: {
+ *    id / todo_id
+ *    description
+ *    done
+ * }
+ */
+
+const todo_read_schema = Joi.object({
+  filter: Joi.object({
+    id: opt_int,
+    todo_id: opt_int,
+    description: opt_str_null,
+    done: bool_null
+  }),
+  options: Joi.object({
+    limit: opt_int
+  })
+})
+
+export const db_todo_read = with_miolo_input_schema(_db_todo_read, todo_read_schema)

package/template/src/server/io/db/todos/toggle.mjs

@@ -0,0 +1,37 @@
+import Joi from "joi"
+import { with_miolo_input_schema } from "miolo"
+import { bool_null, opt_int } from "#server/utils/schema.mjs"
+import { db_todo_find } from "./find.mjs"
+import { db_todo_upsave } from "./upsave.mjs"
+
+async function _db_todo_toggle(ctx, params) {
+  ctx.miolo.logger.verbose(`[db_todo_toggle] Toggling todo with tid ${params?.id}`)
+
+  const todo = await db_todo_find(ctx, params)
+
+  if (todo == null) {
+    throw new Error(`[db_todo_toggle] Trying to toggle a todo that does not exist`)
+  }
+
+  const done = !todo.done
+
+  const todo_data = {
+    id: parseInt(params.id, 10),
+    done
+  }
+
+  const nrecs = await db_todo_upsave(ctx, todo_data)
+
+  ctx.miolo.logger.verbose(
+    `[db_todo_toggle] Toggled todo with tid ${params?.id} (${nrecs} records updated)`
+  )
+
+  return done
+}
+
+const todo_toggle_schema = Joi.object({
+  id: opt_int,
+  done: bool_null
+})
+
+export const db_todo_toggle = with_miolo_input_schema(_db_todo_toggle, todo_toggle_schema)

package/template/src/server/io/db/todos/upsave.mjs

@@ -0,0 +1,32 @@
+import Joi from "joi"
+import { with_miolo_input_schema } from "miolo"
+import { bool_null, opt_int, opt_str_null } from "#server/utils/schema.mjs"
+
+async function _db_todo_upsave(ctx, params) {
+  ctx.miolo.logger.verbose(`[db_todo_upsave] id: ${params?.id || "new"}`)
+
+  const conn = await ctx.miolo.db.get_connection()
+  // TODO : handle transactions
+  const options = { transaction: undefined }
+
+  const Todo = await conn.get_model("todo")
+
+  let tid = params?.id
+  if (params?.id !== undefined) {
+    const nrecs = await Todo.update(params, { id: params.id }, options)
+    ctx.miolo.logger.verbose(`[db_todo_upsave] Updated ${nrecs} todos`)
+  } else {
+    tid = await Todo.insert(params, options)
+    ctx.miolo.logger.verbose(`[db_todo_upsave] Inserted todo with id ${tid}`)
+  }
+
+  return { ...params, id: tid }
+}
+
+const todo_upsave_schema = Joi.object({
+  id: opt_int,
+  description: opt_str_null,
+  done: bool_null
+})
+
+export const db_todo_upsave = with_miolo_input_schema(_db_todo_upsave, todo_upsave_schema)

package/template/src/server/io/db/triggers/user.mjs

@@ -0,0 +1,13 @@
+import { sha512 } from "#server/utils/crypt.mjs"
+
+async function beforeInsertUser(_conn, params, options) {
+  const raw_pwd = params?.password
+  if (raw_pwd) {
+    const cry_pwd = sha512(raw_pwd, process.env.MIOLO_SESSION_SALT)
+    params.password = cry_pwd
+  }
+
+  return [params, options, true]
+}
+
+export { beforeInsertUser }