@raclettejs/core 0.0.1

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/routes/route.user.getAll.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 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<{
+        Querystring: Query;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+    };
+    schema: {
+        summary: string;
+        description: string;
+        tags: string[];
+        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.getAll.js

@@ -0,0 +1,35 @@
+import { Type } from "@sinclair/typebox";
+const QuerySchema = Type.Object({
+    account: Type.Optional(Type.String()),
+});
+export default (fastify) => {
+    const userService = fastify.custom.userService;
+    const handler = async (req, reply) => {
+        try {
+            //TODO rework this once we have permission system in place
+            const filter = { isDeleted: false };
+            if (req.query.account) {
+                filter.account = req.query.account;
+            }
+            const payloads = await userService.readUsers(fastify, req.requestParams, filter);
+            return payloads;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataPush",
+        },
+        schema: {
+            summary: "Get users",
+            description: "Retrieve multiple users by filter criteria",
+            tags: ["core/users"],
+            querystring: QuerySchema,
+        },
+    };
+};

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

@@ -0,0 +1,43 @@
+import type { Static } from "@sinclair/typebox";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { PluginFastifyInstance } from "../../../../../../../types/index.js";
+import { userUpdateSchema } from "../user.schema.js";
+declare const ParamsSchema: import("@sinclair/typebox").TObject<{
+    _id: import("@sinclair/typebox").TString;
+}>;
+type Params = Static<typeof ParamsSchema>;
+type UserBody = Static<typeof userUpdateSchema>;
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Params: Params;
+        Body: UserBody;
+    }>, 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;
+        }>;
+        body: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            email: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            firstname: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            lastname: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            email_verified: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            active: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            blocked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            password: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            ux: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+        }>;
+    };
+};
+export default _default;

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

@@ -0,0 +1,37 @@
+import { Type } from "@sinclair/typebox";
+import { userUpdateSchema } from "../user.schema.js";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const userService = fastify.custom.userService;
+    const handler = async (req, reply) => {
+        try {
+            let cleanBody = req.body;
+            if (!req.user.isAdmin) {
+                delete cleanBody.tags;
+            }
+            const payloadWithUser = await userService.updateUser(fastify, req.requestParams, req.params._id, cleanBody);
+            return payloadWithUser;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataUpdate",
+            broadcastChannels: ["userUpdated"],
+        },
+        schema: {
+            summary: "Update a user",
+            description: "Update specific fields of a user profile",
+            tags: ["core/user"],
+            params: ParamsSchema,
+            body: userUpdateSchema,
+        },
+    };
+};

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

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

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

@@ -0,0 +1,29 @@
+import { Type } from "@sinclair/typebox";
+export default (fastify) => {
+    const userService = fastify.custom.userService;
+    const handler = async (req, reply) => {
+        try {
+            return await userService.updateLastProject(fastify, req.requestParams, req.user._id, req.params.projectId);
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataUpdate",
+            broadcastChannels: ["userUpdated"],
+        },
+        schema: {
+            summary: "Set last accessed project for given user",
+            description: "Takes the user in the provided token and writes the given project id into the user's UX config",
+            tags: ["core/user"],
+            params: Type.Object({
+                projectId: Type.String(),
+            }),
+        },
+    };
+};

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

@@ -0,0 +1,34 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { PluginFastifyInstance } from "../../../../../../../types/index.js";
+import { type UserCreate } from "../user.schema.js";
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Body: UserCreate;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        description: string;
+        tags: string[];
+        body: import("@sinclair/typebox").TObject<{
+            password: import("@sinclair/typebox").TString;
+            account: import("@sinclair/typebox").TString;
+            active: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            blocked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            email: import("@sinclair/typebox").TString;
+            title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            firstname: import("@sinclair/typebox").TString;
+            lastname: import("@sinclair/typebox").TString;
+            email_verified: import("@sinclair/typebox").TBoolean;
+            tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            ux: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            _id: 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.post.js

@@ -0,0 +1,28 @@
+import { userCreateSchema } from "../user.schema.js";
+export default (fastify) => {
+    const userService = fastify.custom.userService;
+    const handler = async (req, reply) => {
+        try {
+            const payloadWithUser = await userService.createUser(fastify, req.requestParams, { ...req.body });
+            return payloadWithUser;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataCreate",
+            broadcastChannels: ["userCreated"],
+        },
+        schema: {
+            summary: "Create a new user",
+            description: "Create a new user with the provided details",
+            tags: ["core/user"],
+            body: userCreateSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/user/routes/route.user.remove.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/user/routes/route.user.remove.js

@@ -0,0 +1,35 @@
+import { Type } from "@sinclair/typebox";
+import { ForbiddenError } from "../../../../../../utils/errors.js";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const userService = fastify.custom.userService;
+    const handler = async (req, reply) => {
+        try {
+            if (req.user._id === req.params._id) {
+                throw new ForbiddenError("A user cannot remove itself");
+            }
+            const payloadWithUser = await userService.removeUser(fastify, req.requestParams, req.params._id);
+            return payloadWithUser;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataDeleted",
+            broadcastChannels: ["userDeleted"],
+        },
+        schema: {
+            summary: "Delete a user",
+            description: "Soft delete a user (marks as deleted but preserves the record)",
+            tags: ["core/user"],
+            params: ParamsSchema,
+        },
+    };
+};

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

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

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

@@ -0,0 +1,145 @@
+import bcrypt from "bcrypt";
+import { v4 as uuidv4 } from "uuid";
+import { randomIdGenerator } from "../../../../../helpers/index.js";
+import mongoose from "mongoose";
+export const MODEL_BASENAME = "user";
+const { Schema } = mongoose;
+const randomId = randomIdGenerator(64);
+const SALT_FACTOR = 10;
+const userSchema = new Schema({
+    _id: {
+        type: String,
+        default: () => uuidv4(),
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+        lowercase: true,
+        trim: true,
+    },
+    account: {
+        type: Schema.Types.String,
+        ref: "raclette__core-account",
+        default: null,
+    },
+    // owner is a required field accross the app, the user usually own themselves
+    owner: {
+        type: Schema.Types.String,
+        ref: "raclette__core-user",
+        default: null,
+    },
+    title: { type: String, default: null },
+    firstname: { type: String, default: null },
+    lastname: { type: String, default: null },
+    email_verified: { type: Boolean, default: false },
+    active: { type: Boolean, default: true },
+    blocked: { type: Boolean, default: false },
+    /* hashed password field */
+    password: { type: String, trim: true },
+    /* keep track of last password update */
+    passwordUpdatedAt: { type: Date, default: null },
+    /* signed terms, we also keep track in the logs of this event */
+    signedTermsAt: { type: Date, default: null },
+    /* reset token, required when user needs to reset password */
+    resetToken: {
+        type: String,
+        index: true,
+        default: null,
+        unique: true,
+        sparse: true,
+    },
+    /*
+     * we need to keep track of last reset request, as the key should only be valid
+     * for a certain time
+     */
+    resetDate: { type: Date, default: null },
+    /* tags, note that tag and this have to belong to the same project */
+    tags: {
+        type: [Schema.Types.String],
+        ref: "raclette__core-tag",
+        default: [],
+    },
+    /* soft delete */
+    isDeleted: { type: Boolean, default: false },
+    /* settings */
+    settings: {
+        emailSignature: { type: String, default: null },
+    },
+    /* matches the configStore entry */
+    ux: {
+        lastProjectId: { type: String, default: null },
+        browser: { type: [Schema.Types.Mixed], default: [] },
+        project: { type: Schema.Types.Mixed, default: null },
+    },
+}, {
+    timestamps: true,
+    optimisticConcurrency: true,
+});
+/*
+ * Pre save
+ *
+ * Before saving the object we need to hash the password
+ */
+userSchema.pre("save", async function (done) {
+    if (!this.isModified("password") ||
+        this.password === undefined ||
+        !this.password ||
+        this.password === null) {
+        this.setResetToken();
+        return done();
+    }
+    if (!this.resetToken || this.resetToken === "") {
+        this.setResetToken();
+    }
+    try {
+        this.password = await this.hashPassword(this.password);
+        if (this.isModified("password")) {
+            this.passwordUpdatedAt = new Date(); // Now this is type-safe
+        }
+        return done();
+    }
+    catch (error) {
+        return done(error);
+    }
+});
+// Index for common queries
+userSchema.index({ email: 1, isDeleted: 1 });
+userSchema.index({ isDeleted: 1 });
+/*
+ * Set Password method
+ */
+userSchema.methods.hashPassword = async (password) => {
+    if (!password) {
+        return undefined;
+    }
+    try {
+        const salt = await bcrypt.genSalt(SALT_FACTOR);
+        return await bcrypt.hash(password, salt);
+    }
+    catch (error) {
+        console.error("Error hashing password", error);
+        throw error;
+    }
+};
+/*
+ * check password method
+ */
+userSchema.methods.checkPassword = async function (guess) {
+    if (!this.password) {
+        throw new Error("Password is not set on the user object");
+    }
+    return bcrypt.compare(guess, this.password);
+};
+/*
+ * set Reset Key
+ * In case the user needs to reset his password, we need a temporary key
+ */
+userSchema.methods.setResetToken = function () {
+    this.resetToken = randomId();
+    this.resetDate = new Date(); // Now this is type-safe
+    return this.resetToken;
+};
+export const createModels = (fastify) => {
+    return fastify.createModel(MODEL_BASENAME, userSchema);
+};

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

@@ -0,0 +1,120 @@
+import type { Static } from "@sinclair/typebox";
+import type { Document } from "mongoose";
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+/**
+ * Full User Schema - Used for response serialization and database model
+ */
+export declare const userSchema: import("@sinclair/typebox").TObject<{
+    password: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    resetToken: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    resetDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    passwordUpdatedAt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    signedTermsAt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    createdAt: import("@sinclair/typebox").TString;
+    updatedAt: import("@sinclair/typebox").TString;
+    isDeleted: import("@sinclair/typebox").TBoolean;
+    email: import("@sinclair/typebox").TString;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    firstname: import("@sinclair/typebox").TString;
+    lastname: import("@sinclair/typebox").TString;
+    email_verified: import("@sinclair/typebox").TBoolean;
+    active: import("@sinclair/typebox").TBoolean;
+    blocked: import("@sinclair/typebox").TBoolean;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    ux: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    _id: import("@sinclair/typebox").TString;
+}>;
+/**
+ * User Create Schema - For POST operations
+ */
+export declare const userCreateSchema: import("@sinclair/typebox").TObject<{
+    password: import("@sinclair/typebox").TString;
+    account: import("@sinclair/typebox").TString;
+    active: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    blocked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    email: import("@sinclair/typebox").TString;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    firstname: import("@sinclair/typebox").TString;
+    lastname: import("@sinclair/typebox").TString;
+    email_verified: import("@sinclair/typebox").TBoolean;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    ux: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    _id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+/**
+ * User Update Schema - For PATCH operations
+ */
+export declare const userUpdateSchema: import("@sinclair/typebox").TObject<{
+    _id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    email: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    firstname: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    lastname: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    email_verified: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    active: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    blocked: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    password: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    ux: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+}>;
+/**
+ * Public User Schema - For external API responses
+ */
+export declare const PublicUserSchema: import("@sinclair/typebox").TObject<{
+    email: import("@sinclair/typebox").TString;
+    _id: import("@sinclair/typebox").TString;
+    owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    passwordUpdatedAt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    signedTermsAt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    createdAt: import("@sinclair/typebox").TString;
+    updatedAt: import("@sinclair/typebox").TString;
+    isDeleted: import("@sinclair/typebox").TBoolean;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    firstname: import("@sinclair/typebox").TString;
+    lastname: import("@sinclair/typebox").TString;
+    email_verified: import("@sinclair/typebox").TBoolean;
+    active: import("@sinclair/typebox").TBoolean;
+    blocked: import("@sinclair/typebox").TBoolean;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    ux: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+}>;
+/**
+ * Type Utilities
+ */
+type DateTimeFields = {
+    resetDate?: Date;
+    passwordUpdatedAt?: Date;
+    signedTermsAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export interface IUserMethods {
+    hashPassword(password: string): Promise<string | undefined>;
+    checkPassword(guess: string): Promise<boolean>;
+    setResetToken(): string;
+}
+type RawUser = Static<typeof userSchema>;
+export type User = Omit<RawUser, keyof DateTimeFields> & DateTimeFields;
+type RawUserCreate = Static<typeof userCreateSchema>;
+export type UserCreate = RawUserCreate;
+type RawUserUpdate = Static<typeof userUpdateSchema>;
+export type UserUpdate = RawUserUpdate;
+export interface UserDoc extends Document, User, IUserMethods {
+    _id: string;
+}
+export type RawPublicUser = Static<typeof PublicUserSchema>;
+export type PublicUser = Omit<RawPublicUser, keyof DateTimeFields> & DateTimeFields;
+export type AnyUser = User | UserDoc;
+export declare const toPublicUser: (user: User | UserDoc) => PublicUser;
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export declare const registerSchemas: (fastify: PluginFastifyInstance) => void;
+export {};