@raclettejs/core 0.0.4 → 0.1.1

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/tag/tag.schema.d.ts

@@ -1,68 +0,0 @@
-import type { Static } from "@sinclair/typebox";
-import type { Document } from "mongoose";
-import type { PluginFastifyInstance } from "../../../../../../types/index.js";
-/**
- * Full Tag Schema - Used for response serialization and database model
- */
-export declare const tagSchema: import("@sinclair/typebox").TObject<{
-    order: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    isDeleted: import("@sinclair/typebox").TBoolean;
-    createdAt: import("@sinclair/typebox").TString;
-    updatedAt: import("@sinclair/typebox").TString;
-    project: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    locked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    color: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    _id: import("@sinclair/typebox").TString;
-}>;
-/**
- * Tag Create Schema - For POST operations
- */
-export declare const tagCreateSchema: import("@sinclair/typebox").TObject<{
-    project: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    locked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    color: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    _id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/**
- * Tag Update Schema - For PATCH operations
- */
-export declare const tagUpdateSchema: import("@sinclair/typebox").TObject<{
-    project: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    color: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    order: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    locked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-}>;
-/**
- * Type Utilities
- */
-type DateTimeFields = {
-    createdAt: Date;
-    updatedAt: Date;
-};
-type RawTag = Static<typeof tagSchema>;
-export type Tag = Omit<RawTag, keyof DateTimeFields> & DateTimeFields;
-type RawTagCreate = Static<typeof tagCreateSchema>;
-export type TagCreate = RawTagCreate;
-type RawTagUpdate = Static<typeof tagUpdateSchema>;
-export type TagUpdate = RawTagUpdate;
-export interface TagDoc extends Document, Tag {
-    _id: string;
-}
-export type AnyTag = Tag | TagDoc;
-/**
- * Register Schema/Type Generation for Shared Folder
- */
-export declare const registerSchemas: (fastify: PluginFastifyInstance) => void;
-export {};

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

@@ -1,71 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { tagTypes } from "../../../../../shared/types/dataTypes/tags.js";
-/**
- * Base Tag Schema - Fields common to all operations
- */
-const baseTagSchema = {
-    project: Type.Optional(Type.String()),
-    owner: Type.Optional(Type.String()),
-    title: Type.Optional(Type.String({ maxLength: 200, default: null })),
-    tags: Type.Optional(Type.Array(Type.String(), { default: [] })),
-    locked: Type.Optional(Type.Boolean({ default: false })),
-    color: Type.Optional(Type.String({ pattern: "^#([0-9a-fA-F]{3}){1,2}$", default: "#CCCCCC" })),
-    type: Type.Optional(Type.String({ enum: tagTypes, maxLength: 50, default: "system" })),
-};
-/**
- * Full Tag Schema - Used for response serialization and database model
- */
-export const tagSchema = Type.Object({
-    _id: Type.String(),
-    ...baseTagSchema,
-    order: Type.Optional(Type.Number({ default: 0 })),
-    isDeleted: Type.Boolean({ default: false }),
-    createdAt: Type.String({ format: "date-time" }),
-    updatedAt: Type.String({ format: "date-time" }),
-}, {
-    $id: "#tag/base",
-    title: "core/tag",
-});
-/**
- * Tag Create Schema - For POST operations
- */
-export const tagCreateSchema = Type.Object({
-    _id: Type.Optional(Type.String()),
-    ...baseTagSchema,
-}, {
-    $id: "#tag/create",
-    title: "core/tag-create",
-});
-/**
- * Tag Update Schema - For PATCH operations
- */
-export const tagUpdateSchema = Type.Object({
-    project: Type.Optional(Type.String()),
-    title: Type.Optional(Type.String({ maxLength: 200 })),
-    tags: Type.Optional(Type.Array(Type.String())),
-    color: Type.Optional(Type.String({ pattern: "^#([0-9a-fA-F]{3}){1,2}$" })),
-    type: Type.Optional(Type.String({ enum: tagTypes, maxLength: 50 })),
-    owner: Type.Optional(Type.String()),
-    order: Type.Optional(Type.Number()),
-    locked: Type.Optional(Type.Boolean()),
-}, {
-    $id: "#tag/update",
-    title: "core/tag-update",
-});
-/**
- * Register Schema/Type Generation for Shared Folder
- */
-export const registerSchemas = (fastify) => {
-    fastify.registerSchema({
-        schema: tagSchema,
-        name: "Tag",
-    });
-    fastify.registerSchema({
-        schema: tagCreateSchema,
-        name: "TagCreate",
-    });
-    fastify.registerSchema({
-        schema: tagUpdateSchema,
-        name: "TagUpdate",
-    });
-};

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

@@ -1,65 +0,0 @@
-import type { TagCreate, Tag as TagType, TagUpdate } from "./tag.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 TagService {
-    private tagModel;
-    constructor(model: Model<TagType>);
-    /**
-     * Core function to create a new tag (returns raw data)
-     */
-    _createTag(fastify: PluginFastifyInstance, tagBody: TagCreate): Promise<TagType>;
-    /**
-     * Create a new tag with payload wrapping and event emission
-     */
-    createTag(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, tagBody: TagCreate): Promise<ClientPayload<TagType[]>>;
-    /**
-     * Core function to read a specific tag by ID (returns raw data)
-     */
-    _readTag(fastify: PluginFastifyInstance, id: string): Promise<TagType>;
-    /**
-     * Read a specific tag by ID with payload wrapping
-     */
-    readTag(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<TagType[]>>;
-    /**
-     * Core function to read tags by ID or filter parameters (returns raw data)
-     */
-    _readTags(fastify: PluginFastifyInstance, filter?: Record<string, any>, options?: QueryOptions): Promise<TagType[]>;
-    /**
-     * Read tags by ID or filter parameters with payload wrapping
-     */
-    readTags(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, filter?: {
-        id?: string;
-        projectId?: string;
-        isDeleted?: boolean;
-    }): Promise<ClientPayload<TagType[]>>;
-    /**
-     * Core function to update an existing tag (returns raw data)
-     */
-    _updateTag(fastify: PluginFastifyInstance, id: string, tagBody: TagUpdate, userId: string): Promise<{
-        updated: TagType;
-        original: TagType;
-    }>;
-    /**
-     * Update an existing tag with payload wrapping and event emission
-     */
-    updateTag(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, tagBody: TagUpdate, userId: string): Promise<ClientPayload<TagType[]>>;
-    /**
-     * Core function to soft delete a tag (returns raw data)
-     */
-    _removeTag(fastify: PluginFastifyInstance, id: string): Promise<TagType>;
-    /**
-     * Soft delete a tag with payload wrapping and event emission
-     */
-    removeTag(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<TagType[]>>;
-    /**
-     * Core function to hard delete a tag (returns raw data)
-     */
-    _hardDeleteTag(fastify: PluginFastifyInstance, id: string): Promise<TagType>;
-    /**
-     * Hard delete a tag with payload wrapping and event emission
-     */
-    hardDeleteTag(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<TagType[]>>;
-}
-export declare const createTagService: (model: Model<TagType>) => TagService;

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

@@ -1,232 +0,0 @@
-import { v4 as uuidv4, validate } from "uuid";
-import { createTagPayload } from "./helpers/payload.js";
-export class TagService {
-    tagModel;
-    constructor(model) {
-        this.tagModel = model;
-    }
-    /**
-     * Core function to create a new tag (returns raw data)
-     */
-    async _createTag(fastify, tagBody) {
-        try {
-            if (tagBody._id) {
-                const uuidValid = validate(tagBody._id);
-                if (!uuidValid) {
-                    throw new Error("Invalid ID - not a valid uuid v4");
-                }
-                const duplicate = await this.tagModel.findById(tagBody._id);
-                if (duplicate) {
-                    throw new Error("An entry with this id already exists");
-                }
-            }
-            else {
-                tagBody._id = uuidv4();
-            }
-            const tag = new this.tagModel(tagBody);
-            await tag.save();
-            fastify.log.info(`[API] Created tag #${tag._id} in project #${tag.project}`);
-            return tag.toObject ? tag.toObject() : tag;
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            throw error;
-        }
-    }
-    /**
-     * Create a new tag with payload wrapping and event emission
-     */
-    async createTag(fastify, requestData, tagBody) {
-        const tag = await this._createTag(fastify, tagBody);
-        const payload = await createTagPayload(fastify, [tag], requestData);
-        fastify.emit("tagCreated", payload);
-        return payload;
-    }
-    /**
-     * Core function to read a specific tag by ID (returns raw data)
-     */
-    async _readTag(fastify, id) {
-        try {
-            const tag = await this.tagModel.findById(id).lean();
-            if (!tag) {
-                throw new Error(`Tag with ID ${id} not found`);
-            }
-            return tag;
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            throw error;
-        }
-    }
-    /**
-     * Read a specific tag by ID with payload wrapping
-     */
-    async readTag(fastify, requestData, id) {
-        const tag = await this._readTag(fastify, id);
-        return createTagPayload(fastify, [tag], requestData);
-    }
-    /**
-     * Core function to read tags by ID or filter parameters (returns raw data)
-     */
-    async _readTags(fastify, filter = { isDeleted: false }, options = {}) {
-        try {
-            // Start building the query
-            let query = this.tagModel.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 tags by ID or filter parameters with payload wrapping
-     */
-    async readTags(fastify, requestData, filter = {
-        isDeleted: false,
-    }) {
-        try {
-            if (filter.id) {
-                // Get single tag
-                const tag = await this._readTag(fastify, filter.id);
-                return createTagPayload(fastify, [tag], requestData);
-            }
-            else {
-                const tags = await this._readTags(fastify, filter);
-                return createTagPayload(fastify, tags, requestData);
-            }
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            throw error;
-        }
-    }
-    /**
-     * Core function to update an existing tag (returns raw data)
-     */
-    async _updateTag(fastify, id, tagBody, userId) {
-        try {
-            const originalTag = await this.tagModel.findById(id);
-            if (!originalTag) {
-                throw new Error(`Tag with ID ${id} not found`);
-            }
-            const updatedTag = await this.tagModel.findByIdAndUpdate(id, { ...tagBody, updatedBy: userId }, { new: true });
-            if (!updatedTag) {
-                throw new Error(`Failed to update tag with ID ${id}`);
-            }
-            fastify.log.info(`[API] Updated tag #${updatedTag._id}`);
-            return {
-                updated: updatedTag.toObject ? updatedTag.toObject() : updatedTag,
-                original: originalTag.toObject ? originalTag.toObject() : originalTag,
-            };
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            throw error;
-        }
-    }
-    /**
-     * Update an existing tag with payload wrapping and event emission
-     */
-    async updateTag(fastify, requestData, id, tagBody, userId) {
-        const _isLockedTag = await this.tagModel.findById(id);
-        const isLockedTag = _isLockedTag?.toObject
-            ? _isLockedTag.toObject()
-            : _isLockedTag;
-        if (isLockedTag?.locked) {
-            throw new Error(`Tag with ID ${id} is locked and can't be updated`);
-        }
-        const { updated, original } = await this._updateTag(fastify, id, tagBody, userId);
-        const payload = await createTagPayload(fastify, [updated], requestData);
-        payload.body.prevVersion = original;
-        if (requestData.broadcast) {
-            fastify.emit("tagUpdated", payload);
-        }
-        return payload;
-    }
-    /**
-     * Core function to soft delete a tag (returns raw data)
-     */
-    async _removeTag(fastify, id) {
-        try {
-            // TODO: Add an universal childCount check
-            const tag = await this.tagModel
-                .findByIdAndUpdate(id, { isDeleted: true }, { new: true })
-                .lean();
-            if (!tag) {
-                throw new Error(`Tag with ID ${id} not found`);
-            }
-            return tag;
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            throw error;
-        }
-    }
-    /**
-     * Soft delete a tag with payload wrapping and event emission
-     */
-    async removeTag(fastify, requestData, id) {
-        const isLockedTag = await this.tagModel.find({ id, locked: true }).lean();
-        if (isLockedTag) {
-            throw new Error(`Tag with ID ${id} is locked and can't be deleted`);
-        }
-        const tag = await this._removeTag(fastify, id);
-        const payload = await createTagPayload(fastify, [tag], {
-            ...requestData,
-            type: "dataDeleted",
-        });
-        payload.body.deleted = [tag._id];
-        fastify.emit("tagDeleted", payload);
-        return payload;
-    }
-    /**
-     * Core function to hard delete a tag (returns raw data)
-     */
-    async _hardDeleteTag(fastify, id) {
-        try {
-            const tag = await this.tagModel.findOne({ _id: id, isDeleted: true });
-            if (!tag) {
-                throw new Error(`Tag with ID ${id} not found or not marked for deletion`);
-            }
-            await this.tagModel.deleteOne({ _id: id });
-            return tag.toObject ? tag.toObject() : tag;
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            throw error;
-        }
-    }
-    /**
-     * Hard delete a tag with payload wrapping and event emission
-     */
-    async hardDeleteTag(fastify, requestData, id) {
-        const isLockedTag = await this.tagModel.find({ id, locked: true }).lean();
-        if (isLockedTag) {
-            throw new Error(`Tag with ID ${id} is locked and can't be hard deleted`);
-        }
-        const tag = await this._hardDeleteTag(fastify, id);
-        const payload = await createTagPayload(fastify, [tag], {
-            ...requestData,
-            type: "dataHardDeleted",
-        });
-        payload.body.deleted = [tag._id];
-        fastify.emit("tagHardDeleted", payload);
-        return payload;
-    }
-}
-export const createTagService = (model) => new TagService(model);

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

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

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

@@ -1,31 +0,0 @@
-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/src/corePlugins/raclette__core/server/datatypes/user/helpers/crud.d.ts

@@ -1,2 +0,0 @@
-import type { PluginFastifyInstance } from "../../../../../../../types/index.js";
-export declare const registerCrud: (fastify: PluginFastifyInstance) => void;

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

@@ -1,9 +0,0 @@
-export const registerCrud = (fastify) => {
-    const userService = fastify.custom.userService;
-    fastify.registerCrudHandlers("user", {
-        create: userService.createUser,
-        read: userService.readUser,
-        update: userService.updateUser,
-        delete: userService.removeUser,
-    });
-};

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

@@ -1,4 +0,0 @@
-import { type User } from "../user.schema.js";
-import type { ClientPayloadRequestData, PluginFastifyInstance } from "../../../../../../../types/index.js";
-export declare const registerPayload: (fastify: PluginFastifyInstance) => void;
-export declare const createUserPayload: (fastify: PluginFastifyInstance, items: User[], requestData: ClientPayloadRequestData) => Promise<any>;

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

@@ -1,11 +0,0 @@
-import { toPublicUser } from "../user.schema.js";
-export const registerPayload = (fastify) => {
-    fastify.registerPayloadHandler("user", {
-        type: "user",
-        displayName: (user) => `${user.firstname} ${user.lastname}`.trim(),
-        completion: (user) => `${user.firstname} ${user.lastname} ${user.email}`,
-        // Sanitization to remove sensitive data
-        sanitize: (user) => toPublicUser(user),
-    });
-};
-export const createUserPayload = async (fastify, items, requestData) => await fastify.createPayload("user", items, requestData);

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

@@ -1,17 +0,0 @@
-import { PluginFastifyInstance } from "../../../../../../types/index.js";
-declare const registerUser: (fastify: PluginFastifyInstance) => Promise<{
-    user: {
-        operations: {
-            read: any;
-            readByMail: any;
-            readAll: any;
-            readCount: any;
-            create: any;
-        };
-        keywords: string[];
-        metadata: {
-            description: string;
-        };
-    };
-}>;
-export default registerUser;

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

@@ -1,51 +0,0 @@
-import registerRoutes from "./routes/index.js";
-import { createUserService } from "./user.service.js";
-import { registerPayload } from "./helpers/payload.js";
-import { registerCrud } from "./helpers/crud.js";
-import { createModels } from "./user.model.js";
-import { registerSchemas } from "./user.schema.js";
-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/src/corePlugins/raclette__core/server/datatypes/user/routes/index.d.ts

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

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

@@ -1,15 +0,0 @@
-import get from "./route.user.get.js";
-import getAll from "./route.user.getAll.js";
-import patch from "./route.user.patch.js";
-import patchLastProject from "./route.user.patchLastProject.js";
-import post from "./route.user.post.js";
-import remove from "./route.user.remove.js";
-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.post("/user", post(fastify));
-    await fastify.delete("/user/:_id", remove(fastify));
-    await fastify.patch("/user/last-project/:projectId", patchLastProject(fastify));
-};
-export default registerRoutes;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/routes/route.user.get.d.ts

@@ -1,33 +0,0 @@
-import type { Static } from "@sinclair/typebox";
-import type { FastifyReply, FastifyRequest } from "fastify";
-import { PluginFastifyInstance } from "../../../../../../../types/index.js";
-declare const ParamsSchema: import("@sinclair/typebox").TObject<{
-    _id: import("@sinclair/typebox").TString;
-}>;
-type Params = Static<typeof ParamsSchema>;
-declare const QuerySchema: import("@sinclair/typebox").TObject<{
-    account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-type Query = Static<typeof QuerySchema>;
-declare const _default: (fastify: PluginFastifyInstance) => {
-    handler: (req: FastifyRequest<{
-        Params: Params;
-        Querystring: Query;
-    }>, reply: FastifyReply) => Promise<any>;
-    onRequest: any[];
-    config: {
-        type: string;
-    };
-    schema: {
-        summary: string;
-        description: string;
-        tags: string[];
-        params: import("@sinclair/typebox").TObject<{
-            _id: import("@sinclair/typebox").TString;
-        }>;
-        querystring: import("@sinclair/typebox").TObject<{
-            account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        }>;
-    };
-};
-export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/routes/route.user.get.js

@@ -1,33 +0,0 @@
-import { Type } from "@sinclair/typebox";
-const ParamsSchema = Type.Object({
-    _id: Type.String(),
-});
-const QuerySchema = Type.Object({
-    account: Type.Optional(Type.String()),
-});
-export default (fastify) => {
-    const userService = fastify.custom.userService;
-    const handler = async (req, reply) => {
-        try {
-            return await userService.readUser(fastify, req.requestParams, req.params._id);
-        }
-        catch (error) {
-            fastify.log.error(error.message);
-            return reply.internalServerError(error.message);
-        }
-    };
-    return {
-        handler,
-        onRequest: [fastify.authenticate],
-        config: {
-            type: "dataPush",
-        },
-        schema: {
-            summary: "Get user",
-            description: "Retrieve a single user by ID ",
-            tags: ["core/user"],
-            params: ParamsSchema,
-            querystring: QuerySchema,
-        },
-    };
-};