@raclettejs/core 0.0.1

package/services/backend/src/corePlugins/raclette__core/frontend/generated-config.ts

@@ -0,0 +1,396 @@
+// Auto-generated frontend configuration for plugin: raclette__core
+// This file is generated from backend routes - do not edit manually
+// Entity mapping: {}
+
+export default {
+  pluginName: "core",
+  author: "raclette",
+  pluginKey: "raclette__core",
+  routePrefix: "/raclette__core",
+  pluginPath: "/app/src/corePlugins/raclette__core",
+  data: {
+    account: {
+      type: "account",
+      operations: {
+        getAll: {
+          target: "/raclette__core/account/all",
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        get: {
+          target: (payload) => `/raclette__core/account/${payload._id}`,
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        update: {
+          target: (payload) => `/raclette__core/account/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--accountUpdated",
+              channelKey: "accountUpdated",
+              prefix: "raclette__core"
+            },
+            {
+              channel: "dataUpdated",
+              channelKey: "broadcastDataUpdated",
+              prefix: ""
+            }
+          ]
+        },
+        create: {
+          target: "/raclette__core/account",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--accountCreated",
+              channelKey: "accountCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/account/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataDelete",
+          channels: [
+            {
+              channel: "raclette__core--accountDeleted",
+              channelKey: "accountDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        deleteHard: {
+          target: (payload) => `/raclette__core/account/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDeleted",
+          channels: [
+            {
+              channel: "raclette__core--accountHardDeleted",
+              channelKey: "accountHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    },
+    interactionLink: {
+      type: "interactionLink",
+      operations: {
+        getAll: {
+          target: "/raclette__core/interactionLink/all",
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        get: {
+          target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        update: {
+          target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--interactionLinkUpdated",
+              channelKey: "interactionLinkUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        create: {
+          target: "/raclette__core/interactionLink",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--interactionLinkCreated",
+              channelKey: "interactionLinkCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataDelete",
+          channels: [
+            {
+              channel: "raclette__core--interactionLinkDeleted",
+              channelKey: "interactionLinkDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        deleteHard: {
+          target: (payload) => `/raclette__core/interactionLink/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDelete",
+          channels: [
+            {
+              channel: "raclette__core--interactionLinkHardDeleted",
+              channelKey: "interactionLinkHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    },
+    project: {
+      type: "project",
+      operations: {
+        getAll: {
+          target: "/raclette__core/project/all",
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        get: {
+          target: (payload) => `/raclette__core/project/${payload._id}`,
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        create: {
+          target: "/raclette__core/project",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--projectCreated",
+              channelKey: "projectCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        update: {
+          target: (payload) => `/raclette__core/project/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--projectUpdated",
+              channelKey: "projectUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/project/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--projectDeleted",
+              channelKey: "projectDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        deleteHard: {
+          target: (payload) => `/raclette__core/project/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDeleted",
+          channels: [
+            {
+              channel: "raclette__core--projectHardDeleted",
+              channelKey: "projectHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    },
+    tag: {
+      type: "tag",
+      operations: {
+        getAll: {
+          target: "/raclette__core/tag/all",
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        get: {
+          target: (payload) => `/raclette__core/tag/${payload._id}`,
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        update: {
+          target: (payload) => `/raclette__core/tag/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--tagUpdated",
+              channelKey: "tagUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        create: {
+          target: (payload) => `/raclette__core/tag/${payload.project}/${payload._id}`,
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--tagCreated",
+              channelKey: "tagCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/tag/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--tagDeleted",
+              channelKey: "tagDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        deleteHard: {
+          target: (payload) => `/raclette__core/tag/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDeleted",
+          channels: [
+            {
+              channel: "raclette__core--tagHardDeleted",
+              channelKey: "tagHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    },
+    user: {
+      type: "user",
+      operations: {
+        getAll: {
+          target: "/raclette__core/user/all",
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        get: {
+          target: (payload) => `/raclette__core/user/${payload._id}`,
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        update: {
+          target: (payload) => `/raclette__core/user/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--userUpdated",
+              channelKey: "userUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        create: {
+          target: "/raclette__core/user",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--userCreated",
+              channelKey: "userCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/user/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataDelete",
+          channels: [
+            {
+              channel: "raclette__core--userDeleted",
+              channelKey: "userDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        updateLastProject: {
+          target: (payload) => `/raclette__core/user/last-project/${payload.projectId}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--userUpdated",
+              channelKey: "userUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    },
+    composition: {
+      type: "composition",
+      operations: {
+        getAll: {
+          target: "/raclette__core/composition/all",
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        get: {
+          target: (payload) => `/raclette__core/composition/${payload._id}`,
+          method: "get",
+          storeActionType: "dataPush"
+        },
+        update: {
+          target: (payload) => `/raclette__core/composition/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--compositionUpdated",
+              channelKey: "compositionUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        create: {
+          target: "/raclette__core/composition",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--compositionCreated",
+              channelKey: "compositionCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/composition/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataDelete",
+          channels: [
+            {
+              channel: "raclette__core--compositionDeleted",
+              channelKey: "compositionDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        deleteHard: {
+          target: (payload) => `/raclette__core/composition/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDelete",
+          channels: [
+            {
+              channel: "raclette__core--compositionHardDeleted",
+              channelKey: "compositionHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    }
+  }
+}

package/services/backend/src/corePlugins/raclette__core/raclette.plugin.ts

@@ -0,0 +1,7 @@
+export default {
+  name: "core",
+  author: "raclette",
+  version: "0.0.1",
+  description:
+    "Contains the raclette relevant core datatypes: account, composition, interactionLink, space, tag, user",
+}

package/services/backend/src/domains/index.ts

@@ -0,0 +1,12 @@
+import type { FastifyInstance } from "fastify"
+
+import registerSystem from "./system"
+
+/*
+ * Core service export all routes
+ */
+const registerCore = async (fastify: FastifyInstance) => {
+  registerSystem(fastify)
+}
+
+export default registerCore

package/services/backend/src/domains/system/index.ts

@@ -0,0 +1,8 @@
+import type { FastifyInstance } from "fastify"
+import registerRoutes from "./routes"
+
+const registerSystem = (fastify: FastifyInstance) => {
+  registerRoutes(fastify)
+}
+
+export default registerSystem

package/services/backend/src/domains/system/routes/index.ts

@@ -0,0 +1,21 @@
+import type { FastifyInstance } from "fastify"
+import {
+  getBlockedLogins,
+  resetLoginBlock,
+  resetAllLoginBlocks,
+} from "./route.admin.cache"
+import deploy from "./route.deploy"
+import login from "./route.user.login"
+import checkToken from "./route.user.checkToken"
+
+const registerRoutes = async (fastify: FastifyInstance) => {
+  await fastify.get("/system/deploy", deploy(fastify))
+
+  await fastify.post("/user/login", login(fastify))
+  await fastify.get("/user/check-token", checkToken(fastify))
+
+  await fastify.get("/admin/cache/blocks", getBlockedLogins(fastify))
+  await fastify.delete("/admin/cache/blocks/:key", resetLoginBlock(fastify))
+  await fastify.delete("/admin/cache/blocks", resetAllLoginBlocks(fastify))
+}
+export default registerRoutes

package/services/backend/src/domains/system/routes/route.admin.cache.ts

@@ -0,0 +1,105 @@
+import type { FastifyInstance, FastifyRequest, FastifyReply } from "fastify"
+import { Type } from "@sinclair/typebox"
+import { CACHE_CONFIG } from "@m/cache/providers/valkey/valkeyConfig"
+
+const { KEY_PREFIXES } = CACHE_CONFIG
+
+export const getBlockedLogins = (fastify: FastifyInstance) => ({
+  schema: {
+    summary: "Get all currently blocked login attempts",
+    tags: ["admin"],
+    response: {
+      200: Type.Array(
+        Type.Object({
+          key: Type.String(),
+          ttl: Type.Number(),
+          attempts: Type.Number(),
+        }),
+      ),
+    },
+  },
+  handler: async (_request: FastifyRequest, reply: FastifyReply) => {
+    const lockKeys = await fastify.cache.keys(`${KEY_PREFIXES.LOGIN_LOCK}*`)
+
+    const blocks = await Promise.all(
+      lockKeys.map(async (key: string) => {
+        const clientKey = key.replace(KEY_PREFIXES.LOGIN_LOCK, "")
+        const attemptsKey = `${KEY_PREFIXES.LOGIN_ATTEMPTS}${clientKey}`
+
+        const [ttl, attempts] = await Promise.all([
+          fastify.cache.ttl(key),
+          fastify.cache.get(attemptsKey),
+        ])
+
+        return {
+          key: clientKey,
+          ttl,
+          attempts: attempts ? parseInt(attempts) : 0,
+        }
+      }),
+    )
+
+    return reply.send(blocks)
+  },
+})
+
+export const resetLoginBlock = (fastify: FastifyInstance) => ({
+  schema: {
+    summary: "Reset login attempts and remove block for specific key",
+    tags: ["admin"],
+    params: Type.Object({
+      key: Type.String(),
+    }),
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+      }),
+    },
+  },
+  handler: async (
+    request: FastifyRequest<{
+      Params: { key: string }
+    }>,
+    reply: FastifyReply,
+  ) => {
+    const { key } = request.params
+
+    await Promise.all([
+      fastify.cache.del(`${KEY_PREFIXES.LOGIN_ATTEMPTS}${key}`),
+      fastify.cache.del(`${KEY_PREFIXES.LOGIN_LOCK}${key}`),
+    ])
+
+    return reply.send({
+      message: `Successfully reset block for ${key}`,
+    })
+  },
+})
+
+export const resetAllLoginBlocks = (fastify: FastifyInstance) => ({
+  schema: {
+    summary: "Reset all login blocks",
+    tags: ["admin"],
+    response: {
+      200: Type.Object({
+        message: Type.String(),
+        count: Type.Number(),
+      }),
+    },
+  },
+  handler: async (_request: FastifyRequest, reply: FastifyReply) => {
+    const lockKeys = await fastify.cache.keys(`${KEY_PREFIXES.LOGIN_LOCK}*`)
+    const attemptKeys = await fastify.cache.keys(
+      `${KEY_PREFIXES.LOGIN_ATTEMPTS}*`,
+    )
+
+    const allKeys = [...lockKeys, ...attemptKeys]
+    if (allKeys.length > 0) {
+      await fastify.cache.del(...allKeys)
+    }
+
+    return reply.send({
+      message: "Successfully reset all blocks",
+      count: lockKeys.length,
+    })
+  },
+})

package/services/backend/src/domains/system/routes/route.deploy.ts

@@ -0,0 +1,24 @@
+import { Type } from "@sinclair/typebox"
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify"
+
+export default (fastify: FastifyInstance) => {
+  const handler = async (req: FastifyRequest, reply: FastifyReply) => {
+    fastify.eventbus.emit("broadcastNewVersionAvailable")
+    fastify.log.info(`[eventbus] new version deployed`)
+
+    reply.send({ success: true })
+  }
+
+  return {
+    handler,
+    schema: {
+      summary: "Will trigger a new deployment information for the websockets",
+      tags: ["system"],
+      response: {
+        200: Type.Object({
+          success: Type.Boolean(),
+        }),
+      },
+    },
+  }
+}

package/services/backend/src/domains/system/routes/route.user.checkToken.ts

@@ -0,0 +1,49 @@
+import type { FastifyReply, FastifyRequest, FastifyInstance } from "fastify"
+import { authenticate } from "@m/authentication"
+import { callDataTypeOperation } from "@c/contracting/contractRegistrar"
+
+export default (fastify: FastifyInstance) => {
+  const checkDatabase = async () => {
+    const userCount = await callDataTypeOperation(
+      "raclette__core",
+      "user",
+      "readCount",
+    )
+
+    return userCount > 0
+  }
+
+  const handler = async (req: FastifyRequest, reply: FastifyReply) => {
+    if (!(await checkDatabase())) {
+      // user database is empty
+      // this is a critical information for the frontend
+      const replyObj = {
+        statusCode: 500,
+        code: "RCLT_DB_NO_USERS",
+        error: "NoUsersInDatabase",
+        message: "No Users in Database",
+      }
+
+      return reply.code(replyObj.statusCode).send(replyObj)
+    }
+    await authenticate(req, reply, fastify)
+
+    // Only send success response if reply hasn't been sent yet
+    if (!reply.sent) {
+      return reply.send(req.user)
+    }
+  }
+
+  return {
+    handler: handler,
+    skipHeaderValidation: true,
+    schema: {
+      summary: "Get a single user.",
+      description: `Retrieve a single user, e.g. to edit the object. Only
+    administrators, project maintainers and the user himself/herself can access
+    this object directly.`,
+      tags: ["core/user"],
+      params: {},
+    },
+  }
+}