@raclettejs/core 0.0.1

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

@@ -0,0 +1,68 @@
+import type { ProjectCreate, Project as ProjectType, ProjectUpdate } from "./project.schema.js";
+import type { ClientPayload, ClientPayloadRequestData } from "../../../../../core/payload/payloadTypes.js";
+import type { QueryOptions } from "../../../../../modules/database/providers/mongodb/service.js";
+import { Model } from "mongoose";
+import { PluginFastifyInstance } from "../../../../../../types/index.js";
+export type ProjectBody = Partial<Omit<ProjectType, "_id">> & {
+    _id?: string;
+};
+export declare class ProjectService {
+    private projectModel;
+    constructor(model: Model<ProjectType>);
+    /**
+     * Core function to create a new project (returns raw data)
+     */
+    _createProject(fastify: PluginFastifyInstance, projectBody: ProjectCreate): Promise<ProjectType>;
+    /**
+     * Create a new project with payload wrapping and event emission
+     */
+    createProject(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, projectBody: ProjectCreate): Promise<ClientPayload<ProjectType[]>>;
+    /**
+     * Core function to read all projects (returns raw data)
+     */
+    _readProjects(fastify: PluginFastifyInstance, filter?: Record<string, any>, options?: QueryOptions): Promise<ProjectType[]>;
+    /**
+     * Read all projects with payload wrapping
+     */
+    readProjects(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, filter?: Record<string, any>, options?: QueryOptions): Promise<ClientPayload<ProjectType[]>>;
+    /**
+     * Core function to get a specific project (returns raw data)
+     */
+    _readProject(fastify: PluginFastifyInstance, id: string): Promise<ProjectType>;
+    /**
+     * Core function to get a specific project (returns raw data)
+     */
+    _readMainProject(fastify: PluginFastifyInstance): Promise<ProjectType>;
+    /**
+     * Get a specific project with payload wrapping
+     */
+    readProject(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<ProjectType[]>>;
+    /**
+     * Core function to update an existing project (returns raw data)
+     */
+    _updateProject(fastify: PluginFastifyInstance, id: string, projectBody: Partial<ProjectUpdate>, userId: string): Promise<{
+        updated: ProjectType;
+        original: ProjectType;
+    }>;
+    /**
+     * Update an existing project with payload wrapping and event emission
+     */
+    updateProject(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, projectBody: Partial<ProjectUpdate>, userId: string): Promise<ClientPayload<ProjectType[]>>;
+    /**
+     * Core function to soft delete a project (returns raw data)
+     */
+    _removeProject(fastify: PluginFastifyInstance, id: string): Promise<ProjectType>;
+    /**
+     * Soft delete a project with payload wrapping and event emission
+     */
+    removeProject(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<ProjectType[]>>;
+    /**
+     * Core function to hard delete a project (returns raw data)
+     */
+    _hardDeleteProject(fastify: PluginFastifyInstance, id: string): Promise<ProjectType>;
+    /**
+     * Hard delete a project with payload wrapping and event emission
+     */
+    hardDeleteProject(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<ProjectType[]>>;
+}
+export declare const createProjectService: (model: Model<ProjectType>) => ProjectService;

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

@@ -0,0 +1,230 @@
+import { v4 as uuidv4, validate } from "uuid";
+import { createProjectPayload } from "./helpers/payload.js";
+// Using a class to preserve 'this' context
+export class ProjectService {
+    projectModel;
+    constructor(model) {
+        this.projectModel = model;
+    }
+    /**
+     * Core function to create a new project (returns raw data)
+     */
+    async _createProject(fastify, projectBody) {
+        try {
+            if (projectBody._id) {
+                const uuidValid = validate(projectBody._id);
+                if (!uuidValid) {
+                    throw new Error("Invalid ID - not a valid uuid v4");
+                }
+                const duplicate = await this.projectModel.findById(projectBody._id);
+                if (duplicate) {
+                    throw new Error("An entry with this id already exists");
+                }
+            }
+            else {
+                projectBody._id = uuidv4();
+            }
+            const project = new this.projectModel(projectBody);
+            await project.save();
+            fastify.log.info(`[API] Created project #${project._id}`);
+            return project.toObject ? project.toObject() : project;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Create a new project with payload wrapping and event emission
+     */
+    async createProject(fastify, requestData, projectBody) {
+        const project = await this._createProject(fastify, projectBody);
+        const payload = await createProjectPayload(fastify, [project], requestData);
+        if (requestData.broadcast) {
+            fastify.emit("projectCreated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to read all projects (returns raw data)
+     */
+    async _readProjects(fastify, filter = { isDeleted: false }, options = {}) {
+        try {
+            // Start building the query
+            let query = this.projectModel.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 all projects with payload wrapping
+     */
+    async readProjects(fastify, requestData, filter, options = {}) {
+        const projects = await this._readProjects(fastify, filter, options);
+        return createProjectPayload(fastify, projects, requestData);
+    }
+    /**
+     * Core function to get a specific project (returns raw data)
+     */
+    async _readProject(fastify, id) {
+        try {
+            const project = await this.projectModel.findById(id).lean();
+            if (!project) {
+                throw new Error(`Project with ID ${id} not found`);
+            }
+            return project;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Core function to get a specific project (returns raw data)
+     */
+    async _readMainProject(fastify) {
+        try {
+            const projects = await this.projectModel.find({ isDefault: true }).lean();
+            if (!projects.length) {
+                throw new Error(`No main project found. This is a crucial error!`);
+            }
+            return projects[0];
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get a specific project with payload wrapping
+     */
+    async readProject(fastify, requestData, id) {
+        const project = await this._readProject(fastify, id);
+        return createProjectPayload(fastify, [project], requestData);
+    }
+    /**
+     * Core function to update an existing project (returns raw data)
+     */
+    async _updateProject(fastify, id, projectBody, userId) {
+        try {
+            const originalProject = await this.projectModel.findById(id);
+            if (!originalProject) {
+                throw new Error(`Project with ID ${id} not found`);
+            }
+            // Remove protected fields
+            delete projectBody._id;
+            delete projectBody.account;
+            const updatedProject = await this.projectModel
+                .findByIdAndUpdate(id, { ...projectBody, updatedBy: userId }, { new: true })
+                .lean();
+            if (!updatedProject) {
+                throw new Error(`Failed to update project with ID ${id}`);
+            }
+            fastify.log.info(`[API] Updated project #${updatedProject._id}`);
+            return {
+                updated: updatedProject,
+                original: originalProject.toObject
+                    ? originalProject.toObject()
+                    : originalProject,
+            };
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Update an existing project with payload wrapping and event emission
+     */
+    async updateProject(fastify, requestData, id, projectBody, userId) {
+        const { updated, original } = await this._updateProject(fastify, id, projectBody, userId);
+        const payload = await createProjectPayload(fastify, [updated], requestData);
+        payload.body.prevVersion = original;
+        if (requestData.broadcast) {
+            fastify.emit("projectUpdated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to soft delete a project (returns raw data)
+     */
+    async _removeProject(fastify, id) {
+        try {
+            const project = await this.projectModel
+                .findByIdAndUpdate(id, { isDeleted: true }, { new: true })
+                .lean();
+            if (!project) {
+                throw new Error(`Project with ID ${id} not found`);
+            }
+            return project;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Soft delete a project with payload wrapping and event emission
+     */
+    async removeProject(fastify, requestData, id) {
+        const project = await this._removeProject(fastify, id);
+        const payload = await createProjectPayload(fastify, [project], {
+            ...requestData,
+            type: "dataDeleted",
+        });
+        payload.body.deleted = [project._id];
+        fastify.emit("projectDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to hard delete a project (returns raw data)
+     */
+    async _hardDeleteProject(fastify, id) {
+        try {
+            const project = await this.projectModel.findOne({
+                _id: id,
+                isDeleted: true,
+            });
+            if (!project) {
+                throw new Error(`Project with ID ${id} not found or not marked for deletion`);
+            }
+            await this.projectModel.deleteOne({ _id: id });
+            return project.toObject ? project.toObject() : project;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Hard delete a project with payload wrapping and event emission
+     */
+    async hardDeleteProject(fastify, requestData, id) {
+        const project = await this._hardDeleteProject(fastify, id);
+        const payload = await createProjectPayload(fastify, [project], {
+            ...requestData,
+            type: "dataHardDeleted",
+        });
+        payload.body.deleted = [project._id];
+        fastify.emit("projectHardDeleted", payload);
+        return payload;
+    }
+}
+export const createProjectService = (model) => new ProjectService(model);

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

@@ -0,0 +1,3 @@
+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/project/routes/index.js

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

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

@@ -0,0 +1,24 @@
+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 _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Params: Params;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;

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

@@ -0,0 +1,33 @@
+import { Type } from "@sinclair/typebox";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const projectService = fastify.custom.projectService;
+    const handler = async (req, reply) => {
+        try {
+            const { _id } = req.params;
+            const payload = await projectService.readProject(fastify, req.requestParams, _id);
+            if (!payload) {
+                return reply.notFound("Project not found");
+            }
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataPush",
+        },
+        schema: {
+            summary: "Get a project by id",
+            tags: ["core/project"],
+            params: ParamsSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.getAll.d.ts

@@ -0,0 +1,15 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { PluginFastifyInstance } from "../../../../../../../types/index.js";
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{}>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: {};
+    };
+};
+export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.getAll.js

@@ -0,0 +1,28 @@
+export default (fastify) => {
+    const projectService = fastify.custom.projectService;
+    const handler = async (req, reply) => {
+        try {
+            const payload = await projectService.readProjects(fastify, req.requestParams);
+            if (!payload) {
+                return reply.code(204);
+            }
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataPush",
+        },
+        schema: {
+            summary: "Get all projects",
+            tags: ["core/project"],
+            params: {},
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.hardDelete.d.ts

@@ -0,0 +1,26 @@
+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 _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Params: Params;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        description: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.hardDelete.js

@@ -0,0 +1,32 @@
+import { Type } from "@sinclair/typebox";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const projectService = fastify.custom.projectService;
+    const handler = async (req, reply) => {
+        try {
+            const { _id } = req.params;
+            const payload = await projectService.hardDeleteProject(fastify, req.requestParams, _id);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataHardDeleted",
+            broadcastChannels: ["projectHardDeleted"],
+        },
+        schema: {
+            summary: "Hard delete a project by id",
+            description: "Permanently removes a project that has been soft deleted",
+            tags: ["core/project"],
+            params: ParamsSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.patch.d.ts

@@ -0,0 +1,38 @@
+import type { ProjectBody } from "../project.service.js";
+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 _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Params: Params;
+        Body: ProjectBody;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+        }>;
+        body: import("@sinclair/typebox").TObject<{
+            isDeleted: import("@sinclair/typebox").TBoolean;
+            createdAt: import("@sinclair/typebox").TString;
+            updatedAt: import("@sinclair/typebox").TString;
+            title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            isDefault: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            _id: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.patch.js

@@ -0,0 +1,33 @@
+import { Type } from "@sinclair/typebox";
+import { projectSchema } from "../project.schema.js";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const projectService = fastify.custom.projectService;
+    const handler = async (req, reply) => {
+        try {
+            const { _id } = req.params;
+            const payload = await projectService.updateProject(fastify, req.requestParams, _id, req.body, req.user._id);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataUpdate",
+            broadcastChannels: ["projectUpdated"],
+        },
+        schema: {
+            summary: "Update a project",
+            tags: ["core/project"],
+            params: ParamsSchema,
+            body: projectSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.post.d.ts

@@ -0,0 +1,25 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { PluginFastifyInstance } from "../../../../../../../types/index.js";
+import { type ProjectCreate } from "../project.schema.js";
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Body: ProjectCreate;
+    }>, reply: FastifyReply) => Promise<any>;
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        body: import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            isDefault: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            _id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+    };
+};
+export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.post.js

@@ -0,0 +1,27 @@
+import { projectCreateSchema } from "../project.schema.js";
+export default (fastify) => {
+    const projectService = fastify.custom.projectService;
+    const handler = async (req, reply) => {
+        try {
+            const payload = await projectService.createProject(fastify, req.requestParams, req.body);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        // onRequest: [fastify.authenticate],
+        config: {
+            type: "dataCreate",
+            broadcastChannels: ["projectCreated"],
+        },
+        schema: {
+            summary: "Create a new project",
+            tags: ["core/project"],
+            body: projectCreateSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.remove.d.ts

@@ -0,0 +1,25 @@
+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 _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Params: Params;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/project/routes/route.project.remove.js

@@ -0,0 +1,31 @@
+import { Type } from "@sinclair/typebox";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const projectService = fastify.custom.projectService;
+    const handler = async (req, reply) => {
+        try {
+            const { _id } = req.params;
+            const payload = await projectService.removeProject(fastify, req.requestParams, _id);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataUpdate",
+            broadcastChannels: ["projectDeleted"],
+        },
+        schema: {
+            summary: "Soft delete a project by id",
+            tags: ["core/project"],
+            params: ParamsSchema,
+        },
+    };
+};

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

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