@raclettejs/core 0.0.1

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/user.schema.js

@@ -0,0 +1,109 @@
+import { Type } from "@sinclair/typebox";
+/**
+ * Base User Schema - Fields common to all operations
+ */
+const baseUserSchema = {
+    email: Type.String({ format: "email" }),
+    title: Type.Optional(Type.String()),
+    firstname: Type.String(),
+    lastname: Type.String(),
+    email_verified: Type.Boolean({ default: false }),
+    active: Type.Boolean({ default: true }),
+    blocked: Type.Boolean({ default: false }),
+    tags: Type.Array(Type.String(), { default: [] }),
+    // TODO: below must be defined better, but also dynamically expandable
+    settings: Type.Optional(Type.Any()),
+    ux: Type.Optional(Type.Any()),
+};
+/**
+ * Full User Schema - Used for response serialization and database model
+ */
+export const userSchema = Type.Object({
+    _id: Type.String({ format: "uuid" }),
+    ...baseUserSchema,
+    password: Type.Optional(Type.String()),
+    owner: Type.Optional(Type.String()),
+    account: Type.Optional(Type.String()),
+    resetToken: Type.Optional(Type.String()),
+    resetDate: Type.Optional(Type.String({ format: "date-time" })),
+    passwordUpdatedAt: Type.Optional(Type.String({ format: "date-time" })),
+    signedTermsAt: Type.Optional(Type.String({ format: "date-time" })),
+    createdAt: Type.String({ format: "date-time" }),
+    updatedAt: Type.String({ format: "date-time" }),
+    isDeleted: Type.Boolean({ default: false }),
+}, {
+    $id: "#user/base",
+    title: "core/user",
+});
+/**
+ * User Create Schema - For POST operations
+ */
+export const userCreateSchema = Type.Object({
+    _id: Type.Optional(Type.String()),
+    ...baseUserSchema,
+    password: Type.String(),
+    account: Type.String(),
+    active: Type.Optional(Type.Boolean({ default: true })),
+    blocked: Type.Optional(Type.Boolean({ default: false })),
+}, {
+    $id: "#user/create",
+    title: "core/user-create",
+});
+/**
+ * User Update Schema - For PATCH operations
+ */
+export const userUpdateSchema = Type.Object({
+    _id: Type.Optional(Type.String()),
+    email: Type.Optional(Type.String({ format: "email" })),
+    title: Type.Optional(Type.String()),
+    firstname: Type.Optional(Type.String()),
+    lastname: Type.Optional(Type.String()),
+    email_verified: Type.Optional(Type.Boolean()),
+    active: Type.Optional(Type.Boolean()),
+    blocked: Type.Optional(Type.Boolean()),
+    tags: Type.Optional(Type.Array(Type.String())),
+    password: Type.Optional(Type.String()),
+    settings: Type.Optional(Type.Any()),
+    ux: Type.Optional(Type.Any()),
+}, {
+    $id: "#user/update",
+    title: "core/user-update",
+});
+/**
+ * Public User Schema - For external API responses
+ */
+export const PublicUserSchema = Type.Omit(userSchema, [
+    "password",
+    "resetToken",
+    "resetDate",
+]);
+// Helper function to convert User to PublicUser
+export const toPublicUser = (user) => {
+    const isUserDoc = (user) => {
+        return "toObject" in user;
+    };
+    // Use the object directly or call toObject based on type
+    const userObj = isUserDoc(user) ? user.toObject() : user;
+    delete userObj.password;
+    delete userObj.resetToken;
+    delete userObj.resetDate;
+    return userObj;
+};
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export const registerSchemas = (fastify) => {
+    fastify.registerSchema({
+        schema: userSchema,
+        publicSchema: PublicUserSchema,
+        name: "User",
+    });
+    fastify.registerSchema({
+        schema: userCreateSchema,
+        name: "UserCreate",
+    });
+    fastify.registerSchema({
+        schema: userUpdateSchema,
+        name: "UserUpdate",
+    });
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/user.service.d.ts

@@ -0,0 +1,69 @@
+import type { PublicUser, UserCreate, User as UserType, UserUpdate } from "./user.schema.js";
+import type { ClientPayload, ClientPayloadRequestData } from "../../../../../core/payload/payloadTypes.js";
+import type { QueryOptions } from "../../../../../modules/database/providers/mongodb/service.js";
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+import type { Model } from "mongoose";
+export declare class UserService {
+    private userModel;
+    constructor(model: Model<UserType>);
+    /**
+     * Core function to create a user (returns raw data)
+     */
+    _createUser(fastify: PluginFastifyInstance, userBody: UserCreate): Promise<UserType>;
+    /**
+     * Create a new user with payload wrapping and event emission
+     */
+    createUser(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, userBody: UserCreate): Promise<ClientPayload<PublicUser[]>>;
+    /**
+     * Core function to read a specific user by ID (returns raw data)
+     */
+    _readUser(fastify: PluginFastifyInstance, id: string): Promise<UserType>;
+    /**
+     * Read a specific user by ID with payload wrapping
+     */
+    readUser(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<PublicUser[]>>;
+    /**
+     * Convenience method for email-based user lookup with password
+     */
+    _readUserByEmail(email: string): Promise<PublicUser | null>;
+    /**
+     * Core function to read multiple users by filter (returns raw data)
+     */
+    _readCount(fastify: PluginFastifyInstance): Promise<Number>;
+    /**
+     * Core function to read multiple users by filter (returns raw data)
+     */
+    _readUsers(fastify: PluginFastifyInstance, filter?: Record<string, any>, options?: QueryOptions): Promise<UserType[]>;
+    /**
+     * Read multiple users by filter with payload wrapping
+     */
+    readUsers(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, filter?: Record<string, any>, options?: QueryOptions): Promise<ClientPayload<PublicUser[]>>;
+    /**
+     * Core function to update an existing user (returns raw data)
+     */
+    _updateUser(fastify: PluginFastifyInstance, id: string, userBody: Partial<UserUpdate>): Promise<{
+        updated: UserType;
+        original: UserType;
+    }>;
+    /**
+     * Update an existing user with payload wrapping and event emission
+     */
+    updateUser(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, userBody: Partial<UserUpdate>): Promise<ClientPayload<PublicUser[]>>;
+    /**
+     * Core function to soft delete a user (returns raw data)
+     */
+    _removeUser(fastify: PluginFastifyInstance, id: string): Promise<UserType>;
+    /**
+     * Soft delete a user with payload wrapping and event emission
+     */
+    removeUser(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<PublicUser[]>>;
+    /**
+     * Core function to update user's last accessed project (returns raw data)
+     */
+    _updateLastProject(fastify: PluginFastifyInstance, userId: string, projectId: string): Promise<UserType>;
+    /**
+     * Update user's last accessed project with payload wrapping
+     */
+    updateLastProject(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, userId: string, projectId: string): Promise<ClientPayload<PublicUser[]>>;
+}
+export declare const createUserService: (model: Model<UserType>) => UserService;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/user.service.js

@@ -0,0 +1,225 @@
+import { v4 as uuidv4, validate } from "uuid";
+import { createUserPayload } from "./helpers/payload.js";
+import { NotFoundError } from "../../../../../utils/errors.js";
+export class UserService {
+    userModel;
+    constructor(model) {
+        this.userModel = model;
+    }
+    /**
+     * Core function to create a user (returns raw data)
+     */
+    async _createUser(fastify, userBody) {
+        try {
+            if (userBody._id) {
+                const uuidValid = validate(userBody._id);
+                if (!uuidValid) {
+                    throw new Error("Invalid ID - not a valid uuid v4");
+                }
+                const duplicate = await this.userModel.findById(userBody._id);
+                if (duplicate) {
+                    throw new Error("An entry with this id already exists");
+                }
+            }
+            else {
+                userBody._id = uuidv4();
+            }
+            const user = new this.userModel(userBody);
+            await user.save();
+            fastify.log.info(`[API] Created user #${user._id}`);
+            return user.toObject ? user.toObject() : user;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Create a new user with payload wrapping and event emission
+     */
+    async createUser(fastify, requestData, userBody) {
+        const user = await this._createUser(fastify, userBody);
+        const payload = await createUserPayload(fastify, [user], requestData);
+        fastify.emit("userCreated", payload);
+        return payload;
+    }
+    /**
+     * Core function to read a specific user by ID (returns raw data)
+     */
+    async _readUser(fastify, id) {
+        try {
+            const user = await this.userModel.findById(id).lean();
+            if (!user) {
+                throw new NotFoundError(`User with ID ${id} not found`);
+            }
+            return user;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Read a specific user by ID with payload wrapping
+     */
+    async readUser(fastify, requestData, id) {
+        const user = await this._readUser(fastify, id);
+        return createUserPayload(fastify, [user], requestData);
+    }
+    /**
+     * Convenience method for email-based user lookup with password
+     */
+    async _readUserByEmail(email) {
+        return await this.userModel
+            .findOne({ email, isDeleted: false })
+            .populate("account")
+            .select("+password");
+    }
+    /**
+     * Core function to read multiple users by filter (returns raw data)
+     */
+    async _readCount(fastify) {
+        return await this.userModel.countDocuments({ isDeleted: false });
+    }
+    /**
+     * Core function to read multiple users by filter (returns raw data)
+     */
+    async _readUsers(fastify, filter = { isDeleted: false }, options = {}) {
+        try {
+            // Start building the query
+            let query = this.userModel.find(filter);
+            // Apply pagination if provided
+            if (options.limit !== undefined) {
+                query = query.limit(options.limit);
+            }
+            if (options.offset !== undefined) {
+                query = query.skip(options.offset);
+            }
+            // Apply population if provided
+            if (options.populate && Array.isArray(options.populate)) {
+                options.populate.forEach((populateOption) => {
+                    query = query.populate(populateOption);
+                });
+            }
+            // Execute query
+            return await query.lean();
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Read multiple users by filter with payload wrapping
+     */
+    async readUsers(fastify, requestData, filter = {}, options = {}) {
+        const users = await this._readUsers(fastify, filter, options);
+        return createUserPayload(fastify, users, requestData);
+    }
+    /**
+     * Core function to update an existing user (returns raw data)
+     */
+    async _updateUser(fastify, id, userBody) {
+        try {
+            const originalUser = await this.userModel.findById(id);
+            if (!originalUser) {
+                throw new NotFoundError(`User with ID ${id} not found`);
+            }
+            delete userBody._id;
+            // Handle password separately if provided
+            if (userBody.password) {
+                originalUser.password = userBody.password;
+                await originalUser.save();
+                delete userBody.password;
+            }
+            const updatedUser = await this.userModel.findByIdAndUpdate(id, { ...userBody }, { new: true });
+            if (!updatedUser) {
+                throw new Error(`Failed to update user with ID ${id}`);
+            }
+            fastify.log.info(`[API] Updated user #${updatedUser._id}`);
+            return {
+                updated: updatedUser.toObject ? updatedUser.toObject() : updatedUser,
+                original: originalUser.toObject
+                    ? originalUser.toObject()
+                    : originalUser,
+            };
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Update an existing user with payload wrapping and event emission
+     */
+    async updateUser(fastify, requestData, id, userBody) {
+        const { updated, original } = await this._updateUser(fastify, id, userBody);
+        const payload = await createUserPayload(fastify, [updated], requestData);
+        payload.body.prevVersion = original;
+        if (requestData.broadcast) {
+            fastify.emit("userUpdated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to soft delete a user (returns raw data)
+     */
+    async _removeUser(fastify, id) {
+        try {
+            const user = await this.userModel
+                .findByIdAndUpdate(id, { isDeleted: true }, { new: true })
+                .lean();
+            if (!user) {
+                throw new NotFoundError(`User with ID ${id} not found`);
+            }
+            return user;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Soft delete a user with payload wrapping and event emission
+     */
+    async removeUser(fastify, requestData, id) {
+        const user = await this._removeUser(fastify, id);
+        const payload = await createUserPayload(fastify, [user], {
+            ...requestData,
+            type: "dataDeleted",
+        });
+        payload.body.deleted = [user._id];
+        fastify.emit("userDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to update user's last accessed project (returns raw data)
+     */
+    async _updateLastProject(fastify, userId, projectId) {
+        try {
+            const user = await this.userModel
+                .findOneAndUpdate({ _id: userId }, { "ux.lastProjectId": projectId }, { new: true })
+                .lean();
+            if (!user) {
+                throw new NotFoundError(`User with ID ${userId} not found`);
+            }
+            fastify.log.info(`[API] Updated last project for user #${userId} to ${projectId}`);
+            return user;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Update user's last accessed project with payload wrapping
+     */
+    async updateLastProject(fastify, requestData, userId, projectId) {
+        const user = await this._updateLastProject(fastify, userId, projectId);
+        return createUserPayload(fastify, [user], {
+            ...requestData,
+            type: "dataUpdate",
+        });
+    }
+}
+export const createUserService = (model) => new UserService(model);

package/services/backend/dist/src/corePlugins/raclette__core/server/index.d.ts

@@ -0,0 +1,3 @@
+import type { PluginFastifyInstance, PluginOptions } from "../../../../types/index.js";
+declare const racletteCorePlugin: (fastify: PluginFastifyInstance, opts: PluginOptions) => Promise<void>;
+export default racletteCorePlugin;

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

@@ -0,0 +1,32 @@
+import registerAccount from "./datatypes/account/index.js";
+import registerComposition from "./datatypes/composition/index.js";
+import registerInteractionLink from "./datatypes/interactionLink/index.js";
+import registerTag from "./datatypes/tag/index.js";
+import registerUser from "./datatypes/user/index.js";
+import registerProject from "./datatypes/project/index.js";
+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),
+    ]);
+    // 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/src/domains/index.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+declare const registerCore: (fastify: FastifyInstance) => Promise<void>;
+export default registerCore;

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

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

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

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+declare const registerSystem: (fastify: FastifyInstance) => void;
+export default registerSystem;

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

@@ -0,0 +1,5 @@
+import registerRoutes from "./routes/index.js";
+const registerSystem = (fastify) => {
+    registerRoutes(fastify);
+};
+export default registerSystem;

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

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+declare const registerRoutes: (fastify: FastifyInstance) => void;
+export default registerRoutes;

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

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

package/services/backend/dist/src/domains/system/routes/route.admin.redis.d.ts

@@ -0,0 +1,47 @@
+import type { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+export declare const getBlockedLogins: (fastify: FastifyInstance) => {
+    schema: {
+        summary: string;
+        tags: string[];
+        response: {
+            200: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                key: import("@sinclair/typebox").TString;
+                ttl: import("@sinclair/typebox").TNumber;
+                attempts: import("@sinclair/typebox").TNumber;
+            }>>;
+        };
+    };
+    handler: (_request: FastifyRequest, reply: FastifyReply) => Promise<never>;
+};
+export declare const resetLoginBlock: (fastify: FastifyInstance) => {
+    schema: {
+        summary: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            key: import("@sinclair/typebox").TString;
+        }>;
+        response: {
+            200: import("@sinclair/typebox").TObject<{
+                message: import("@sinclair/typebox").TString;
+            }>;
+        };
+    };
+    handler: (request: FastifyRequest<{
+        Params: {
+            key: string;
+        };
+    }>, reply: FastifyReply) => Promise<never>;
+};
+export declare const resetAllLoginBlocks: (fastify: FastifyInstance) => {
+    schema: {
+        summary: string;
+        tags: string[];
+        response: {
+            200: import("@sinclair/typebox").TObject<{
+                message: import("@sinclair/typebox").TString;
+                count: import("@sinclair/typebox").TNumber;
+            }>;
+        };
+    };
+    handler: (_request: FastifyRequest, reply: FastifyReply) => Promise<never>;
+};

package/services/backend/dist/src/domains/system/routes/route.admin.redis.js

@@ -0,0 +1,81 @@
+import { Type } from "@sinclair/typebox";
+import { REDIS_CONFIG } from "../../../modules/cache/providers/redis/redisConfig.js";
+const { KEY_PREFIXES } = REDIS_CONFIG;
+export const getBlockedLogins = (fastify) => ({
+    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, reply) => {
+        const lockKeys = await fastify.redis.keys(`${KEY_PREFIXES.LOGIN_LOCK}*`);
+        const blocks = await Promise.all(lockKeys.map(async (key) => {
+            const clientKey = key.replace(KEY_PREFIXES.LOGIN_LOCK, "");
+            const attemptsKey = `${KEY_PREFIXES.LOGIN_ATTEMPTS}${clientKey}`;
+            const [ttl, attempts] = await Promise.all([
+                fastify.redis.ttl(key),
+                fastify.redis.get(attemptsKey),
+            ]);
+            return {
+                key: clientKey,
+                ttl,
+                attempts: attempts ? parseInt(attempts) : 0,
+            };
+        }));
+        return reply.send(blocks);
+    },
+});
+export const resetLoginBlock = (fastify) => ({
+    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, reply) => {
+        const { key } = request.params;
+        await Promise.all([
+            fastify.redis.del(`${KEY_PREFIXES.LOGIN_ATTEMPTS}${key}`),
+            fastify.redis.del(`${KEY_PREFIXES.LOGIN_LOCK}${key}`),
+        ]);
+        return reply.send({
+            message: `Successfully reset block for ${key}`,
+        });
+    },
+});
+export const resetAllLoginBlocks = (fastify) => ({
+    schema: {
+        summary: "Reset all login blocks",
+        tags: ["admin"],
+        response: {
+            200: Type.Object({
+                message: Type.String(),
+                count: Type.Number(),
+            }),
+        },
+    },
+    handler: async (_request, reply) => {
+        const lockKeys = await fastify.redis.keys(`${KEY_PREFIXES.LOGIN_LOCK}*`);
+        const attemptKeys = await fastify.redis.keys(`${KEY_PREFIXES.LOGIN_ATTEMPTS}*`);
+        const allKeys = [...lockKeys, ...attemptKeys];
+        if (allKeys.length > 0) {
+            await fastify.redis.del(...allKeys);
+        }
+        return reply.send({
+            message: "Successfully reset all blocks",
+            count: lockKeys.length,
+        });
+    },
+});

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

@@ -0,0 +1,14 @@
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+declare const _default: (fastify: FastifyInstance) => {
+    handler: (req: FastifyRequest, reply: FastifyReply) => Promise<void>;
+    schema: {
+        summary: string;
+        tags: string[];
+        response: {
+            200: import("@sinclair/typebox").TObject<{
+                success: import("@sinclair/typebox").TBoolean;
+            }>;
+        };
+    };
+};
+export default _default;

package/services/backend/dist/src/domains/system/routes/route.deploy.js

@@ -0,0 +1,20 @@
+import { Type } from "@sinclair/typebox";
+export default (fastify) => {
+    const handler = async (req, reply) => {
+        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/dist/src/domains/system/routes/route.user.checkToken.d.ts

@@ -0,0 +1,12 @@
+import type { FastifyReply, FastifyRequest, FastifyInstance } from "fastify";
+declare const _default: (fastify: FastifyInstance) => {
+    handler: (req: FastifyRequest, reply: FastifyReply) => Promise<never>;
+    skipHeaderValidation: boolean;
+    schema: {
+        summary: string;
+        description: string;
+        tags: string[];
+        params: {};
+    };
+};
+export default _default;