@raclettejs/core 0.1.31 → 0.1.32-nightly

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/interactionLink/index.js

@@ -0,0 +1,48 @@
+import registerRoutes from "./routes";
+import { createModels } from "./interactionLink.model";
+import { createInteractionLinkService } from "./interactionLink.service";
+import { registerCrud } from "./helpers/crud";
+import { registerPayload } from "./helpers/payload";
+import { registerSchemas } from "./interactionLink.schema";
+const registerInteractionLink = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const interactionLinkModel = createModels(fastify);
+    // create and pass in the model to your service
+    const interactionLinkService = createInteractionLinkService(interactionLinkModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.interactionLinkService = interactionLinkService;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerPayload(fastify);
+    registerCrud(fastify);
+    registerSchemas(fastify);
+    return {
+        interactionLink: {
+            operations: {
+                readAll: interactionLinkService._readAllInteractionLinks.bind(interactionLinkService),
+                read: interactionLinkService._readInteractionLink.bind(interactionLinkService),
+                create: interactionLinkService._createInteractionLink.bind(interactionLinkService),
+                delete: interactionLinkService._removeInteractionLink.bind(interactionLinkService),
+            },
+            keywords: ["interaction", "link", "connection", "relation"],
+            metadata: {
+                description: "Links between interactive elements",
+            },
+        },
+    };
+};
+export default registerInteractionLink;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/interactionLink/routes/index.js

@@ -0,0 +1,19 @@
+import get from "./route.interactionLink.get";
+import getAll from "./route.interactionLink.getAll";
+import hardDelete from "./route.interactionLink.hardDelete";
+import patch from "./route.interactionLink.patch";
+import post from "./route.interactionLink.post";
+import postBulk from "./route.interactionLink.post.bulk";
+import remove from "./route.interactionLink.remove";
+import restore from "./route.interactionLink.restore";
+const registerRoutes = async (fastify) => {
+    await fastify.get("/interactionLink/all", getAll(fastify));
+    await fastify.get("/interactionLink/:_id", get(fastify));
+    await fastify.patch("/interactionLink/:_id", patch(fastify));
+    await fastify.patch("/interactionLink/:_id/restore", restore(fastify));
+    await fastify.post("/interactionLink", post(fastify));
+    await fastify.post("/interactionLink/bulk", postBulk(fastify));
+    await fastify.delete("/interactionLink/:_id", remove(fastify));
+    await fastify.delete("/interactionLink/:_id/hard", hardDelete(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/project/events/index.js

@@ -0,0 +1,31 @@
+const registerEvents = (fastify) => {
+    /**
+     * Project created
+     */
+    const created = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.eventbus.emit("broadcastProjectCreated", payload);
+        fastify.log.info(`[eventbus] project broadcast created ${payload.body.item._id}`);
+    };
+    /**
+     * Project updated
+     */
+    const updated = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] project broadcast updated ${payload.body.item._id}`);
+    };
+    /**
+     * Project deleted
+     */
+    const deleted = async (payload) => {
+        fastify.eventbus.emit("broadcastProjectDeleted", payload);
+        fastify.log.info(`[eventbus] project broadcast deleted ${payload.body.item._id}`);
+    };
+    /**
+     * Register event handlers
+     */
+    fastify.eventbus.on("coreProjectCreated", created);
+    fastify.eventbus.on("coreProjectUpdated", updated);
+    fastify.eventbus.on("coreProjectDeleted", deleted);
+};
+export default registerEvents;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/project/index.js

@@ -0,0 +1,49 @@
+import registerRoutes from "./routes";
+import { createModels } from "./project.model";
+import { createProjectService } from "./project.service";
+import { registerPayload } from "./helpers/payload";
+import { registerCrud } from "./helpers/crud";
+import { registerSchemas } from "./project.schema";
+const registerProject = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const projectModel = createModels(fastify);
+    // create and pass in the model to your service
+    const projectService = createProjectService(projectModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.projectService = projectService;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerPayload(fastify);
+    registerCrud(fastify);
+    registerSchemas(fastify);
+    return {
+        project: {
+            operations: {
+                read: projectService._readProject.bind(projectService),
+                readMain: projectService._readMainProject.bind(projectService),
+                readAll: projectService._readProjects.bind(projectService),
+                create: projectService._createProject.bind(projectService),
+                update: projectService._updateProject.bind(projectService),
+            },
+            keywords: ["project", "space"],
+            metadata: {
+                description: "The space the user is using the app in.",
+            },
+        },
+    };
+};
+export default registerProject;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/project/routes/index.js

@@ -0,0 +1,16 @@
+import get from "./route.project.get";
+import getAll from "./route.project.getAll";
+import patch from "./route.project.patch";
+import post from "./route.project.post";
+//import hardDelete from "./route.project.hardDelete"
+//import remove from "./route.project.remove"
+const registerRoutes = async (fastify) => {
+    await fastify.get("/project/all", getAll(fastify));
+    await fastify.get("/project/:_id", get(fastify));
+    await fastify.post("/project", post(fastify));
+    await fastify.patch("/project/:_id", patch(fastify));
+    // TODO reenable once we have deletion concept and space datatype implemented
+    //await fastify.delete("/project/:_id", remove(fastify))
+    //await fastify.delete("/project/:_id/hard", hardDelete(fastify))
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/tag/events/index.js

@@ -0,0 +1,39 @@
+export const registerEvents = (fastify) => {
+    /*
+     * tag created and created
+     */
+    const created = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.eventbus.emit("broadcastTagCreated", payload);
+        fastify.log.info(`[eventbus] tag broadcast created ${payload.body.items}`);
+    };
+    /*
+     * tag updated and created
+     */
+    const updated = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] tag broadcast updated ${payload.body.items}`);
+    };
+    /*
+     * makes sure child counts between tickets and tags gets updated
+     */
+    const tagArrayUpdated = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] tag broadcast created ${payload.body.items}`);
+    };
+    /*
+     * tag deleted
+     */
+    const deleted = async (payload) => {
+        fastify.eventbus.emit("broadcastTagDeleted", payload);
+        fastify.log.info(`[eventbus] tag broadcast deleted ${payload.body.items}`);
+    };
+    /**
+     * Register those functions for eventbus events
+     */
+    fastify.eventbus.on("coreTagCreated", created);
+    fastify.eventbus.on("coreTagUpdated", updated);
+    fastify.eventbus.on("coreTagDeleted", deleted);
+    fastify.eventbus.on("coreTagArrayUpdated", tagArrayUpdated);
+};
+export default registerEvents;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/tag/index.js

@@ -0,0 +1,50 @@
+import registerRoutes from "./routes";
+import { createModels } from "./tag.model";
+import { createTagService } from "./tag.service";
+import { registerPayload } from "./helpers/payload";
+import { registerCrud } from "./helpers/crud";
+import { registerSchemas } from "./tag.schema";
+const registerTag = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const tagModel = createModels(fastify);
+    // create and pass in the model to your service
+    const tagService = createTagService(tagModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.tagService = tagService;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerPayload(fastify);
+    registerCrud(fastify);
+    registerSchemas(fastify);
+    return {
+        tag: {
+            operations: {
+                readAll: tagService._readTags.bind(tagService),
+                read: tagService._readTag.bind(tagService),
+                readByTitle: tagService._readTagByTitle.bind(tagService),
+                create: tagService._createTag.bind(tagService),
+                update: tagService._updateTag.bind(tagService),
+                delete: tagService._removeTag.bind(tagService),
+            },
+            keywords: ["tag", "keyword", "buzzword", "label"],
+            metadata: {
+                description: "Allows labels for every possible data type",
+            },
+        },
+    };
+};
+export default registerTag;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/tag/routes/index.js

@@ -0,0 +1,19 @@
+import get from "./route.tag.get";
+import getAll from "./route.tag.getAll";
+import hardDelete from "./route.tag.hardDelete";
+import patch from "./route.tag.patch";
+import post from "./route.tag.post";
+import postBulk from "./route.tag.post.bulk";
+import remove from "./route.tag.remove";
+import restore from "./route.tag.restore";
+const registerRoutes = async (fastify) => {
+    await fastify.get("/tag/all", getAll(fastify));
+    await fastify.get("/tag/:_id", get(fastify));
+    await fastify.patch("/tag/:_id", patch(fastify));
+    await fastify.patch("/tag/:_id/restore", restore(fastify));
+    await fastify.post("/tag/:project/:_id", post(fastify));
+    await fastify.post("/tag/bulk", postBulk(fastify));
+    await fastify.delete("/tag/:_id", remove(fastify));
+    await fastify.delete("/tag/:_id/hard", hardDelete(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/user/events/index.js

@@ -0,0 +1,31 @@
+export const registerEvents = (fastify) => {
+    /*
+     * user created
+     */
+    const created = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.eventbus.emit("broadcastUserCreated", payload);
+        fastify.log.info(`[eventbus] user broadcast created ${payload.body.items}`);
+    };
+    /*
+     * user updated
+     */
+    const updated = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] user broadcast updated ${payload.body.items}`);
+    };
+    /*
+     * user deleted
+     */
+    const deleted = async (payload) => {
+        fastify.eventbus.emit("broadcastUserDeleted", payload);
+        fastify.log.info(`[eventbus] user broadcast deleted ${payload.body.items}`);
+    };
+    /**
+     * Register those functions for eventbus events
+     */
+    fastify.eventbus.on("coreUserCreated", created);
+    fastify.eventbus.on("coreUserUpdated", updated);
+    fastify.eventbus.on("coreUserDeleted", deleted);
+};
+export default registerEvents;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/user/index.js

@@ -0,0 +1,51 @@
+import registerRoutes from "./routes";
+import { createUserService } from "./user.service";
+import { registerPayload } from "./helpers/payload";
+import { registerCrud } from "./helpers/crud";
+import { createModels } from "./user.model";
+import { registerSchemas } from "./user.schema";
+const registerUser = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const userModel = createModels(fastify);
+    // create and pass in the model to your service
+    const userService = createUserService(userModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.userService = userService;
+    // because the user has more than the standard routes, we need to decorate the model to the instance
+    fastify.custom.userModel = userModel;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerPayload(fastify);
+    registerCrud(fastify);
+    registerSchemas(fastify);
+    return {
+        user: {
+            operations: {
+                read: userService._readUser.bind(userService),
+                readByMail: userService._readUserByEmail.bind(userService),
+                readAll: userService._readUsers.bind(userService),
+                readCount: userService._readCount.bind(userService),
+                create: userService._createUser.bind(userService),
+            },
+            keywords: ["user", "auth", "identity", "account"],
+            metadata: {
+                description: "User management and authentication",
+            },
+        },
+    };
+};
+export default registerUser;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/user/routes/index.js

@@ -0,0 +1,21 @@
+import get from "./route.user.get";
+import getAll from "./route.user.getAll";
+import patch from "./route.user.patch";
+import patchOwn from "./route.user.patchOwn";
+import patchLastProject from "./route.user.patchLastProject";
+import post from "./route.user.post";
+import remove from "./route.user.remove";
+import hardDelete from "./route.user.hardDelete";
+import restore from "./route.user.restore";
+const registerRoutes = async (fastify) => {
+    await fastify.get("/user/all", getAll(fastify));
+    await fastify.get("/user/:_id", get(fastify));
+    await fastify.patch("/user/:_id", patch(fastify));
+    await fastify.patch("/user/self", patchOwn(fastify));
+    await fastify.patch("/user/:_id/restore", restore(fastify));
+    await fastify.post("/user", post(fastify));
+    await fastify.delete("/user/:_id", remove(fastify));
+    await fastify.delete("/user/:_id/hard", hardDelete(fastify));
+    await fastify.patch("/user/last-project/:projectId", patchLastProject(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/workSession/events/index.js

@@ -0,0 +1,31 @@
+const registerEvents = (fastify) => {
+    /**
+     * WorkSession created
+     */
+    const created = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.eventbus.emit("broadcastWorkSessionCreated", payload);
+        fastify.log.info(`[eventbus] workSession broadcast created ${payload.body.item._id}`);
+    };
+    /**
+     * WorkSession updated
+     */
+    const updated = async (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] workSession broadcast updated ${payload.body.item._id}`);
+    };
+    /**
+     * WorkSession deleted
+     */
+    const deleted = async (payload) => {
+        fastify.eventbus.emit("broadcastWorkSessionDeleted", payload);
+        fastify.log.info(`[eventbus] workSession broadcast deleted ${payload.body.item._id}`);
+    };
+    /**
+     * Register event handlers
+     */
+    fastify.eventbus.on("coreWorkSessionCreated", created);
+    fastify.eventbus.on("coreWorkSessionUpdated", updated);
+    fastify.eventbus.on("coreWorkSessionDeleted", deleted);
+};
+export default registerEvents;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/workSession/index.js

@@ -0,0 +1,48 @@
+import registerRoutes from "./routes";
+import { createModels } from "./workSession.model";
+import { createWorkSessionService } from "./workSession.service";
+import { registerPayload } from "./helpers/payload";
+import { registerCrud } from "./helpers/crud";
+import { registerSchemas } from "./workSession.schema";
+const registerWorkSession = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const workSessionModel = createModels(fastify);
+    // create and pass in the model to your service
+    const workSessionService = createWorkSessionService(workSessionModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.workSessionService = workSessionService;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerPayload(fastify);
+    registerCrud(fastify);
+    registerSchemas(fastify);
+    return {
+        workSession: {
+            operations: {
+                read: workSessionService._readWorkSession.bind(workSessionService),
+                readAll: workSessionService._readWorkSessions.bind(workSessionService),
+                create: workSessionService._createWorkSession.bind(workSessionService),
+                update: workSessionService._updateWorkSession.bind(workSessionService),
+            },
+            keywords: ["workSession", "session"],
+            metadata: {
+                description: "A work session for user interactions.",
+            },
+        },
+    };
+};
+export default registerWorkSession;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/workSession/routes/index.js

@@ -0,0 +1,15 @@
+import get from "./route.workSession.get";
+import getAll from "./route.workSession.getAll";
+import patch from "./route.workSession.patch";
+import post from "./route.workSession.post";
+import hardDelete from "./route.workSession.hardDelete";
+import remove from "./route.workSession.remove";
+const registerRoutes = async (fastify) => {
+    await fastify.get("/workSession/all", getAll(fastify));
+    await fastify.get("/workSession/:_id", get(fastify));
+    await fastify.post("/workSession", post(fastify));
+    await fastify.patch("/workSession/:_id", patch(fastify));
+    await fastify.delete("/workSession/:_id", remove(fastify));
+    await fastify.delete("/workSession/:_id/hard", hardDelete(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/index.js

@@ -0,0 +1,34 @@
+import registerAccount from "./datatypes/account";
+import registerComposition from "./datatypes/composition";
+import registerInteractionLink from "./datatypes/interactionLink";
+import registerTag from "./datatypes/tag";
+import registerUser from "./datatypes/user";
+import registerProject from "./datatypes/project";
+import registerWorkSession from "./datatypes/workSession";
+const racletteCorePlugin = async (fastify, opts) => {
+    fastify.log.info("raclette Core Plugin");
+    // Register all datatypes in parallel and collect their contracts
+    const contractRegistrations = await Promise.all([
+        registerAccount(fastify),
+        registerComposition(fastify),
+        registerInteractionLink(fastify),
+        registerProject(fastify),
+        registerTag(fastify),
+        registerUser(fastify),
+        registerWorkSession(fastify),
+    ]);
+    // Combine all contract snippets into one plugin contract
+    const pluginContract = contractRegistrations.reduce((acc, contract) => {
+        if (contract && typeof contract === "object") {
+            return {
+                ...acc,
+                ...contract,
+            };
+        }
+        return acc;
+    }, {});
+    // Register the complete contract
+    fastify.registerPluginContract(pluginContract);
+    fastify.registerForFrontendGeneration({});
+};
+export default racletteCorePlugin;

package/services/backend/dist/domains/index.js

@@ -0,0 +1,11 @@
+import registerSystem from "./system";
+/*
+ * Core service export all routes
+ */
+const registerCore = async (fastify) => {
+    if (!fastify.core) {
+        fastify.core = {};
+    }
+    registerSystem(fastify);
+};
+export default registerCore;

package/services/backend/dist/domains/system/index.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+import registerRoutes from "./routes";
+import { createCollectionService } from "./collections.service";
+const registerSystem = (fastify) => {
+    registerRoutes(fastify);
+    // create and pass in the model to your service
+    const collectionService = createCollectionService(mongoose.connection);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.core.collectionService = collectionService;
+};
+export default registerSystem;

package/services/backend/dist/domains/system/routes/index.js

@@ -0,0 +1,17 @@
+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";
+import getAllCollections from "./route.collection.getAll";
+import deleteCollections from "./route.collection.remove";
+const registerRoutes = async (fastify) => {
+    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));
+    await fastify.get("/admin/collections/all", getAllCollections(fastify));
+    await fastify.delete("/admin/collections", deleteCollections(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/helpers/index.js

@@ -0,0 +1,14 @@
+import { customAlphabet } from "nanoid";
+export * from "./cors";
+const customCyperAlphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/**
+ * Random ID generator
+ *
+ * @param length - Required length for the output
+ * @returns Function that generates random IDs
+ * @example
+ * const generateId = randomIdGenerator(12);
+ * const id = generateId(); // => 'gdh6326GDJh0'
+ */
+const randomIdGenerator = (length = 16) => customAlphabet(customCyperAlphabet, length);
+export { randomIdGenerator };

package/services/backend/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./utils";
+export * from "./core/contracting/contractRegistrar";