new selfhosted version

dashboard/server/api/members/accept.post.ts

@@ -0,0 +1,26 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'flag:allowAnonRegistered');
+    const { user_id, user_email } = ctx;
+
+    const body = await readBody(event);
+
+    const { project_id } = body;
+    if (!project_id) throw createError({ status: 400, message: 'project_id is required' });
+
+    const member = await TeamMemberModel.findOne({
+        project_id, $or: [
+            { user_id },
+            { email: user_email }
+        ]
+    });
+    if (!member) throw createError({ status: 400, message: 'Member not found' });
+
+    member.pending = false;
+    await member.save();
+
+    return { ok: true };
+
+});

dashboard/server/api/members/add.post.ts

@@ -0,0 +1,94 @@
+
+import { TeamMemberModel } from "@schema/TeamMemberSchema";
+import { UserModel } from "@schema/UserSchema";
+import { z } from "zod";
+import { getPlanFromId } from "~/shared/data/PLANS";
+import { PremiumModel } from "~/shared/schema/PremiumSchema";
+
+const ZEmailBody = z.object({
+    email: z.string().email('Not a valid email')
+});
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'pid');
+    const { project_id, user_id, project } = ctx;
+
+    const { email } = await readValidatedBody(event, ZEmailBody.parse);
+
+    const { BASE_URL } = useRuntimeConfig();
+
+    const link = `${BASE_URL}/accept_invite?project_id=${project_id.toString()}`;
+
+    const premiumData = await PremiumModel.findOne({ user_id });
+    if (!premiumData) throw createError({ status: 400, message: 'Error getting premiumData. Please contact support.' });
+
+    const price = getPlanFromId(premiumData.premium_type);
+    if (!price) throw createError({ status: 400, message: 'Error getting price. Please contact support.' });
+
+    const maxMembers = price.features.members;
+    const currentMembers = await TeamMemberModel.countDocuments({ project_id });
+
+    if (currentMembers >= maxMembers) throw createError({ status: 400, message: 'MEMBERS_LIMIT_REACHED' });
+
+    const targetUser = await UserModel.findOne({ email });
+
+    if (targetUser) {
+
+        if (targetUser._id.toString() == user_id) throw createError({ status: 400, message: 'Cannot invite yourself' });
+
+        const exists = await TeamMemberModel.exists({ project_id, user_id });
+        if (exists) throw createError({ status: 400, message: 'Member already invited' });
+
+        await TeamMemberModel.create({
+            project_id,
+            user_id: targetUser.id,
+            pending: true,
+            role: 'GUEST',
+            permission: {
+                webAnalytics: true,
+                events: false,
+                ai: false,
+                domains: ['*']
+            }
+        });
+
+        setImmediate(() => {
+            const tRpc = useTRPC();
+            tRpc.emails.email.sendInviteEmail.mutate({ email, project_name: project.name, link });
+        });
+
+
+    } else {
+
+
+        const exist = await TeamMemberModel.exists({ project_id, email });
+        if (exist) return setResponseStatus(event, 400, 'Member already invited');
+
+        await TeamMemberModel.create({
+            project_id,
+            email,
+            pending: true,
+            role: 'GUEST',
+            permission: {
+                webAnalytics: true,
+                events: false,
+                ai: false,
+                domains: ['*']
+            }
+        });
+
+
+        setImmediate(() => {
+            const tRpc = useTRPC();
+            tRpc.emails.email.sendInviteEmail.mutate({ email, project_name: project.name, link });
+        });
+
+
+    }
+
+
+    return { ok: true };
+
+
+});

dashboard/server/api/members/decline.post.ts

@@ -0,0 +1,25 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'flag:allowAnonRegistered');
+    const { user_id, user_email } = ctx;
+
+    const body = await readBody(event);
+
+    const { project_id } = body;
+    if (!project_id) throw createError({ status: 400, message: 'project_id is required' });
+
+    const member = await TeamMemberModel.deleteOne({
+        project_id,
+        $or: [
+            { user_id },
+            { email: user_email }
+        ]
+    });
+
+    if (!member) return setResponseStatus(event, 400, 'Member not found');
+
+    return { ok: true };
+
+});

dashboard/server/api/members/edit.post.ts

@@ -0,0 +1,29 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'pid');
+
+    const { user_id, project } = ctx;
+
+    const body = await readBody(event);
+    const { member_id, webAnalytics, events, ai, domains } = body;
+
+    const isOwner = user_id === project.owner.toString();
+    if (!isOwner) throw createError({ status: 403, message: 'Only owner can change roles' })
+
+    if (!member_id) return setResponseStatus(event, 400, 'member_id is required');
+
+    const edited = await TeamMemberModel.updateOne({ _id: member_id }, {
+        permission: {
+            webAnalytics,
+            events,
+            ai,
+            domains
+        }
+    });
+
+    return { ok: edited.modifiedCount == 1 }
+
+});

dashboard/server/api/members/kick.post.ts

@@ -0,0 +1,22 @@
+
+import { TeamMemberModel } from "@schema/TeamMemberSchema";
+import { UserModel } from "@schema/UserSchema";
+
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'pid');
+    const { project_id } = ctx;
+
+    const { email } = await readBody(event);
+
+    const user = await UserModel.findOne({ email });
+    if (user) {
+        await TeamMemberModel.deleteOne({ project_id, user_id: user.id });
+    } else {
+        await TeamMemberModel.deleteOne({ project_id, email: email });
+    }
+
+    return { ok: true }
+
+});

dashboard/server/api/members/leave.ts

@@ -0,0 +1,7 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+    const ctx = await getRequestContext(event, 'pid', 'permission:member');
+    const { project_id, user_id } = ctx;
+    await TeamMemberModel.deleteOne({ project_id, user_id });
+});

dashboard/server/api/members/list.ts

@@ -0,0 +1,83 @@
+import { EventModel } from "@schema/metrics/EventSchema";
+import { Redis } from "~/server/services/CacheService";
+import { executeTimelineAggregation } from "~/server/services/TimelineService";
+import { TeamMemberModel, TeamMemberRole, TPermission } from "~/shared/schema/TeamMemberSchema";
+import { TUser, UserModel } from "~/shared/schema/UserSchema";
+
+
+export type MemberWithPermissions = {
+    id: string | null,
+    email: string,
+    role: TeamMemberRole,
+    pending: boolean,
+    me: boolean,
+    permission: TPermission
+}
+
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'pid');
+    const { project_id, user_id, user_email, project } = ctx;
+
+    const result: MemberWithPermissions[] = [];
+
+    const members = await TeamMemberModel.find({ project_id });
+
+    result.push({
+        id: user_id,
+        email: user_email,
+        role: 'OWNER',
+        me: user_id === project.owner.toString(),
+        pending: false,
+        permission: {
+            webAnalytics: true,
+            domains: ['*'],
+            ai: true,
+            events: true
+        }
+    })
+
+    for (const member of members) {
+
+        let userMember: TUser | null;
+
+        if (member.user_id) {
+            userMember = await UserModel.findOne({ _id: member.user_id });
+        } else {
+            userMember = await UserModel.findOne({ email: member.email });
+        }
+
+        const permission: TPermission = {
+            webAnalytics: member.permission?.webAnalytics || false,
+            events: member.permission?.events || false,
+            ai: member.permission?.ai || false,
+            domains: member.permission?.domains || []
+        }
+
+        if (userMember) {
+            result.push({
+                id: member.id,
+                email: userMember.email || member.email || 'NO_EMAIL',
+                role: member.role,
+                pending: member.pending,
+                me: user_id === ((userMember as any).id.toString() || member.user_id || 'NO_ID'),
+                permission
+            })
+        } else {
+            result.push({
+                id: member.id,
+                email: member.email ?? 'error',
+                role: member.role,
+                pending: member.pending,
+                me: false,
+                permission: member.permission
+            })
+        }
+
+
+    }
+
+    return result;
+
+});

dashboard/server/api/members/me.ts

@@ -0,0 +1,25 @@
+import { TeamMemberModel } from "~/shared/schema/TeamMemberSchema";
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'pid', 'permission:member');
+    const { project_id, user_id, user_email, project } = ctx;
+
+    if (project.owner.toString() === user_id) {
+        return { webAnalytics: true, domains: ['*'], ai: true, events: true }
+    }
+
+    //TODO: Create admin list
+    if (user_email === 'helplitlyx@gmail.com') {
+        return { webAnalytics: true, domains: ['*'], ai: true, events: true }
+    }
+
+    const meUserId = await TeamMemberModel.findOne({ project_id, user_id });
+    if (meUserId) return meUserId.permission;
+
+    const meEmail = await TeamMemberModel.findOne({ project_id, email: user_email });
+    if (meEmail) return meEmail.permission;
+
+    return { webAnalytics: false, domains: [], ai: false, events: false }
+
+});

dashboard/server/api/members/pending.ts

@@ -0,0 +1,53 @@
+
+import { TeamMemberModel } from "@schema/TeamMemberSchema";
+import { Types } from "mongoose";
+
+export type TPendingInvite = {
+    _id: string,
+    project_id: string,
+    user_id: string,
+    role: string,
+    pending: boolean,
+    creted_at: string,
+    project_name: string
+};
+
+export default defineEventHandler(async event => {
+
+    const ctx = await getRequestContext(event, 'pid');
+    const { user_id, user_email } = ctx;
+
+    const members = await TeamMemberModel.aggregate([
+        {
+            $match:
+            {
+                $or: [
+                    { user_id: new Types.ObjectId(user_id) },
+                    { email: user_email }
+                ],
+                pending: true
+            }
+        },
+        {
+            $lookup: {
+                from: 'projects',
+                as: 'project',
+                foreignField: '_id',
+                localField: 'project_id',
+            }
+        },
+        {
+            $addFields: {
+                project_name: { $arrayElemAt: ["$project.name", 0] }
+            }
+        },
+        {
+            $project: {
+                project: 0
+            }
+        }
+    ]);
+
+    return members;
+
+});