@raclettejs/core 0.0.4 → 0.1.1

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

@@ -1,109 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,225 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,5 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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;