Merge branch 'docmost:main' into main

The email says "${invitedUserName} has accepted your invitation ...", so it makes more sense to send it to the inviter instead of the invitee.

.env.example

@@ -7,18 +7,6 @@ APP_SECRET=REPLACE_WITH_LONG_SECRET
 
 JWT_TOKEN_EXPIRES_IN=30d
 
-# Use NTLM for user authentication, exposes to browser
-VITE_NTLM_AUTH=false
-
-# LDAP settings for NTLM authentication
-LDAP_BASEDN=
-LDAP_DOMAINSUFFIX=
-LDAP_USERNAME=
-LDAP_PASSWORD=
-# User object attributes for docmost
-LDAP_NAMEATTRIBUTE=
-LDAP_MAILATTRIBUTE=
-
 DATABASE_URL="postgresql://postgres:password@localhost:5432/docmost?schema=public"
 REDIS_URL=redis://127.0.0.1:6379
 
@@ -44,6 +32,7 @@ SMTP_PORT=587
 SMTP_USERNAME=
 SMTP_PASSWORD=
 SMTP_SECURE=false
+SMTP_IGNORETLS=false
 
 # Postmark driver config
 POSTMARK_TOKEN=

.github/workflows/main.yml

@@ -0,0 +1,47 @@
+name: Sync Merged-Downstream with Docmost Upstream Main
+
+on:
+  schedule:
+    - cron: '0 0 * * *' # Run daily at midnight UTC
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0 # Fetch all history to detect changes properly
+
+    - name: Set up git
+      run: |
+        git config --global user.name "Shadowfita"
+        git config --global user.email "www.ryan.palmer@hotmail.com"
+
+    - name: Fetch upstream
+      run: |
+        git remote add upstream https://github.com/docmost/docmost.git
+        git fetch upstream
+
+    - name: Check if upstream has changes
+      id: check_changes
+      run: |
+        UPSTREAM_DIFF=$(git diff --name-only upstream/main)
+        if [ -z "$UPSTREAM_DIFF" ]; then
+          echo "No changes in upstream main branch."
+          echo "::set-output name=changes::false"
+        else
+          echo "Changes detected in upstream main branch."
+          echo "::set-output name=changes::true"
+        fi
+
+    - name: Merge upstream/main into Merged-Downstream
+      if: steps.check_changes.outputs.changes == 'true'
+      run: |
+        git checkout Merged-Downstream
+        git merge upstream/main
+
+    - name: Push changes to Merged-Downstream
+      if: steps.check_changes.outputs.changes == 'true'
+      run: |
+        git push origin Merged-Downstream

README.md

@@ -17,6 +17,7 @@ To get started with Docmost, please refer to our [documentation](https://docmost
 
 ## Features
 - Real-time collaboration
+- Diagrams (Draw.io, Excalidraw and Mermaid)
 - Spaces
 - Permissions management
 - Groups
@@ -32,4 +33,4 @@ To get started with Docmost, please refer to our [documentation](https://docmost
 </p>
 
 ### Contributing 
-See the [development doc](https://docmost.com/docs/self-hosting/development)
+See the [development documentation](https://docmost.com/docs/self-hosting/development)

apps/client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "client",
   "private": true,
-  "version": "0.3.0",
+  "version": "0.3.1",
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
@@ -41,7 +41,6 @@
     "react-drawio": "^0.2.0",
     "react-error-boundary": "^4.0.13",
     "react-helmet-async": "^2.0.5",
-    "react-moveable": "^0.56.0",
     "react-router-dom": "^6.26.1",
     "socket.io-client": "^4.7.5",
     "tippy.js": "^6.3.7",

apps/client/src/App.tsx

@@ -24,6 +24,8 @@ import PageRedirect from "@/pages/page/page-redirect.tsx";
 import Layout from "@/components/layouts/global/layout.tsx";
 import { ErrorBoundary } from "react-error-boundary";
 import InviteSignup from "@/pages/auth/invite-signup.tsx";
+import ForgotPassword from "@/pages/auth/forgot-password.tsx";
+import PasswordReset from "./pages/auth/password-reset";
 
 export default function App() {
   const [, setSocket] = useAtom(socketAtom);
@@ -63,6 +65,8 @@ export default function App() {
         <Route path={"/login"} element={<LoginPage />} />
         <Route path={"/invites/:invitationId"} element={<InviteSignup />} />
         <Route path={"/setup/register"} element={<SetupWorkspace />} />
+        <Route path={"/forgot-password"} element={<ForgotPassword />} />
+        <Route path={"/password-reset"} element={<PasswordReset />} />
 
         <Route path={"/p/:pageSlug"} element={<PageRedirect />} />
 

apps/client/src/components/common/recent-changes.tsx

@@ -5,14 +5,15 @@ import {
   Badge,
   Table,
   ScrollArea,
-} from "@mantine/core";
+  ActionIcon,
-import { Link } from "react-router-dom";
+} from '@mantine/core';
-import PageListSkeleton from "@/components/ui/page-list-skeleton.tsx";
+import { Link } from 'react-router-dom';
-import { buildPageUrl } from "@/features/page/page.utils.ts";
+import PageListSkeleton from '@/components/ui/page-list-skeleton.tsx';
-import { formattedDate } from "@/lib/time.ts";
+import { buildPageUrl } from '@/features/page/page.utils.ts';
-import { useRecentChangesQuery } from "@/features/page/queries/page-query.ts";
+import { formattedDate } from '@/lib/time.ts';
-import { IconFileDescription } from "@tabler/icons-react";
+import { useRecentChangesQuery } from '@/features/page/queries/page-query.ts';
-import { getSpaceUrl } from "@/lib/config.ts";
+import { IconFileDescription } from '@tabler/icons-react';
+import { getSpaceUrl } from '@/lib/config.ts';
 
 interface Props {
   spaceId?: string;
@@ -40,10 +41,14 @@ export default function RecentChanges({ spaceId }: Props) {
                   to={buildPageUrl(page?.space.slug, page.slugId, page.title)}
                 >
                   <Group wrap="nowrap">
-                    {page.icon || <IconFileDescription size={18} />}
+                    {page.icon || (
+                      <ActionIcon variant='transparent' color='gray' size={18}>
+                        <IconFileDescription size={18} />
+                      </ActionIcon>
+                    )}
 
                     <Text fw={500} size="md" lineClamp={1}>
-                      {page.title || "Untitled"}
+                      {page.title || 'Untitled'}
                     </Text>
                   </Group>
                 </UnstyledButton>
@@ -55,7 +60,7 @@ export default function RecentChanges({ spaceId }: Props) {
                     variant="light"
                     component={Link}
                     to={getSpaceUrl(page?.space.slug)}
-                    style={{ cursor: "pointer" }}
+                    style={{ cursor: 'pointer' }}
                   >
                     {page?.space.name}
                   </Badge>

apps/client/src/components/ui/error-404.tsx

@@ -1,19 +1,25 @@
 import { Title, Text, Button, Container, Group } from "@mantine/core";
 import classes from "./error-404.module.css";
 import { Link } from "react-router-dom";
+import { Helmet } from "react-helmet-async";
 
 export function Error404() {
   return (
-    <Container className={classes.root}>
+    <>
-      <Title className={classes.title}>404 Page Not Found</Title>
+      <Helmet>
-      <Text c="dimmed" size="lg" ta="center" className={classes.description}>
+        <title>404 page not found - Docmost</title>
-        Sorry, we can't find the page you are looking for.
+      </Helmet>
-      </Text>
+      <Container className={classes.root}>
-      <Group justify="center">
+        <Title className={classes.title}>404 Page Not Found</Title>
-        <Button component={Link} to={"/home"} variant="subtle" size="md">
+        <Text c="dimmed" size="lg" ta="center" className={classes.description}>
-          Take me back to homepage
+          Sorry, we can't find the page you are looking for.
-        </Button>
+        </Text>
-      </Group>
+        <Group justify="center">
-    </Container>
+          <Button component={Link} to={"/home"} variant="subtle" size="md">
+            Take me back to homepage
+          </Button>
+        </Group>
+      </Container>
+    </>
   );
 }

apps/client/src/features/auth/components/forgot-password-form.tsx

@@ -0,0 +1,70 @@
+import { useState } from "react";
+import * as z from "zod";
+import { useForm, zodResolver } from "@mantine/form";
+import useAuth from "@/features/auth/hooks/use-auth";
+import { IForgotPassword } from "@/features/auth/types/auth.types";
+import { Box, Button, Container, Text, TextInput, Title } from "@mantine/core";
+import classes from "./auth.module.css";
+import { useRedirectIfAuthenticated } from "@/features/auth/hooks/use-redirect-if-authenticated.ts";
+
+const formSchema = z.object({
+  email: z
+    .string()
+    .min(1, { message: "Email is required" })
+    .email({ message: "Invalid email address" }),
+});
+
+export function ForgotPasswordForm() {
+  const { forgotPassword, isLoading } = useAuth();
+  const [isTokenSent, setIsTokenSent] = useState<boolean>(false);
+  useRedirectIfAuthenticated();
+
+  const form = useForm<IForgotPassword>({
+    validate: zodResolver(formSchema),
+    initialValues: {
+      email: "",
+    },
+  });
+
+  async function onSubmit(data: IForgotPassword) {
+    if (await forgotPassword(data)) {
+      setIsTokenSent(true);
+    }
+  }
+
+  return (
+    <Container size={420} my={40} className={classes.container}>
+      <Box p="xl" mt={200}>
+        <Title order={2} ta="center" fw={500} mb="md">
+          Forgot password
+        </Title>
+
+        <form onSubmit={form.onSubmit(onSubmit)}>
+          {!isTokenSent && (
+            <TextInput
+              id="email"
+              type="email"
+              label="Email"
+              placeholder="email@example.com"
+              variant="filled"
+              {...form.getInputProps("email")}
+            />
+          )}
+
+          {isTokenSent && (
+            <Text>
+              A password reset link has been sent to your email. Please check
+              your inbox.
+            </Text>
+          )}
+
+          {!isTokenSent && (
+            <Button type="submit" fullWidth mt="xl" loading={isLoading}>
+              Send reset link
+            </Button>
+          )}
+        </form>
+      </Box>
+    </Container>
+  );
+}

apps/client/src/features/auth/components/login-form.tsx

@@ -1,4 +1,3 @@
-import * as React from "react";
 import * as z from "zod";
 import { useForm, zodResolver } from "@mantine/form";
 import useAuth from "@/features/auth/hooks/use-auth";
@@ -10,9 +9,13 @@ import {
   Button,
   PasswordInput,
   Box,
+
+  Anchor,
 } from "@mantine/core";
 import classes from "./auth.module.css";
 import { useRedirectIfAuthenticated } from "@/features/auth/hooks/use-redirect-if-authenticated.ts";
+import { Link, useNavigate } from "react-router-dom";
+import APP_ROUTE from "@/lib/app-route.ts";
 
 const formSchema = z.object({
   email: z
@@ -62,10 +65,20 @@ export function LoginForm() {
             mt="md"
             {...form.getInputProps("password")}
           />
+
           <Button type="submit" fullWidth mt="xl" loading={isLoading}>
             Sign In
           </Button>
         </form>
+
+        <Anchor
+          to={APP_ROUTE.AUTH.FORGOT_PASSWORD}
+          component={Link}
+          underline="never"
+          size="sm"
+        >
+          Forgot your password?
+        </Anchor>
       </Box>
     </Container>
   );

apps/client/src/features/auth/components/password-reset-form.tsx

@@ -0,0 +1,67 @@
+import * as z from "zod";
+import { useForm, zodResolver } from "@mantine/form";
+import useAuth from "@/features/auth/hooks/use-auth";
+import { IPasswordReset } from "@/features/auth/types/auth.types";
+import {
+  Box,
+  Button,
+  Container,
+  PasswordInput,
+  Text,
+  Title,
+} from "@mantine/core";
+import classes from "./auth.module.css";
+import { useRedirectIfAuthenticated } from "@/features/auth/hooks/use-redirect-if-authenticated.ts";
+
+const formSchema = z.object({
+  newPassword: z
+    .string()
+    .min(8, { message: "Password must contain at least 8 characters" }),
+});
+
+interface PasswordResetFormProps {
+  resetToken?: string;
+}
+
+export function PasswordResetForm({ resetToken }: PasswordResetFormProps) {
+  const { passwordReset, isLoading } = useAuth();
+  useRedirectIfAuthenticated();
+
+  const form = useForm<IPasswordReset>({
+    validate: zodResolver(formSchema),
+    initialValues: {
+      newPassword: "",
+    },
+  });
+
+  async function onSubmit(data: IPasswordReset) {
+    await passwordReset({
+      token: resetToken,
+      newPassword: data.newPassword
+    })
+  }
+
+  return (
+    <Container size={420} my={40} className={classes.container}>
+      <Box p="xl" mt={200}>
+        <Title order={2} ta="center" fw={500} mb="md">
+          Password reset
+        </Title>
+
+        <form onSubmit={form.onSubmit(onSubmit)}>
+          <PasswordInput
+            label="New password"
+            placeholder="Your new password"
+            variant="filled"
+            mt="md"
+            {...form.getInputProps("newPassword")}
+          />
+
+          <Button type="submit" fullWidth mt="xl" loading={isLoading}>
+            Set password
+          </Button>
+        </form>
+      </Box>
+    </Container>
+  );
+}

apps/client/src/features/auth/hooks/use-auth.ts

@@ -1,10 +1,22 @@
 import { useState } from "react";
-import { login, ntlmLogin, setupWorkspace } from "@/features/auth/services/auth-service";
+import {
+  forgotPassword,
+  login,
+  passwordReset,
+  setupWorkspace,
+  verifyUserToken,
+} from "@/features/auth/services/auth-service";
 import { useNavigate } from "react-router-dom";
 import { useAtom } from "jotai";
 import { authTokensAtom } from "@/features/auth/atoms/auth-tokens-atom";
 import { currentUserAtom } from "@/features/user/atoms/current-user-atom";
-import { ILogin, ISetupWorkspace } from "@/features/auth/types/auth.types";
+import {
+  IForgotPassword,
+  ILogin,
+  IPasswordReset,
+  ISetupWorkspace,
+  IVerifyUserToken,
+} from "@/features/auth/types/auth.types";
 import { notifications } from "@mantine/notifications";
 import { IAcceptInvite } from "@/features/workspace/types/workspace.types.ts";
 import { acceptInvitation } from "@/features/workspace/services/workspace-service.ts";
@@ -38,25 +50,6 @@ export default function useAuth() {
     }
   };
 
-  const handleNtlmSignIn = async () => {
-    setIsLoading(true);
-
-    try {
-      const res = await ntlmLogin();
-      setIsLoading(false);
-      setAuthToken(res.tokens);
-
-      navigate(APP_ROUTE.HOME);
-    } catch (err) {
-      console.log(err);
-      setIsLoading(false);
-      notifications.show({
-        message: err.response?.data.message,
-        color: "red",
-      });
-    }
-  };
-
   const handleInvitationSignUp = async (data: IAcceptInvite) => {
     setIsLoading(true);
 
@@ -95,6 +88,28 @@ export default function useAuth() {
     }
   };
 
+  const handlePasswordReset = async (data: IPasswordReset) => {
+    setIsLoading(true);
+
+    try {
+      const res = await passwordReset(data);
+      setIsLoading(false);
+
+      setAuthToken(res.tokens);
+
+      navigate(APP_ROUTE.HOME);
+      notifications.show({
+        message: "Password reset was successful",
+      });
+    } catch (err) {
+      setIsLoading(false);
+      notifications.show({
+        message: err.response?.data.message,
+        color: "red",
+      });
+    }
+  };
+
   const handleIsAuthenticated = async () => {
     if (!authToken) {
       return false;
@@ -124,12 +139,50 @@ export default function useAuth() {
     navigate(APP_ROUTE.AUTH.LOGIN);
   };
 
+  const handleForgotPassword = async (data: IForgotPassword) => {
+    setIsLoading(true);
+
+    try {
+      await forgotPassword(data);
+      setIsLoading(false);
+
+      return true;
+    } catch (err) {
+      console.log(err);
+      setIsLoading(false);
+      notifications.show({
+        message: err.response?.data.message,
+        color: "red",
+      });
+
+      return false;
+    }
+  };
+
+  const handleVerifyUserToken = async (data: IVerifyUserToken) => {
+    setIsLoading(true);
+
+    try {
+      await verifyUserToken(data);
+      setIsLoading(false);
+    } catch (err) {
+      console.log(err);
+      setIsLoading(false);
+      notifications.show({
+        message: err.response?.data.message,
+        color: "red",
+      });
+    }
+  };
+
   return {
     signIn: handleSignIn,
-    ntlmSignIn: handleNtlmSignIn,
     invitationSignup: handleInvitationSignUp,
     setupWorkspace: handleSetupWorkspace,
     isAuthenticated: handleIsAuthenticated,
+    forgotPassword: handleForgotPassword,
+    passwordReset: handlePasswordReset,
+    verifyUserToken: handleVerifyUserToken,
     logout: handleLogout,
     hasTokens,
     isLoading,

apps/client/src/features/auth/queries/auth-query.tsx

@@ -0,0 +1,14 @@
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+import { verifyUserToken } from "../services/auth-service";
+import { IVerifyUserToken } from "../types/auth.types";
+
+export function useVerifyUserTokenQuery(
+    verify: IVerifyUserToken,
+  ): UseQueryResult<any, Error> {
+    return useQuery({
+      queryKey: ["verify-token", verify],
+      queryFn: () => verifyUserToken(verify),
+      enabled: !!verify.token,
+      staleTime: 0,
+    });
+  }

apps/client/src/features/auth/services/auth-service.ts

@@ -1,24 +1,20 @@
 import api from "@/lib/api-client";
 import {
   IChangePassword,
+  IForgotPassword,
   ILogin,
+  IPasswordReset,
   IRegister,
   ISetupWorkspace,
   ITokenResponse,
+  IVerifyUserToken,
 } from "@/features/auth/types/auth.types";
-import axios from "axios";
 
 export async function login(data: ILogin): Promise<ITokenResponse> {
   const req = await api.post<ITokenResponse>("/auth/login", data);
   return req.data;
 }
 
-export async function ntlmLogin(): Promise<ITokenResponse> {
-  // Use separate axios instance to avoid passing app auth headers to allow for NTLM authentication challenge
-  const req = await axios.post<ITokenResponse>("/api/auth/ntlm");
-  return req.data;
-}
-
 /*
 export async function register(data: IRegister): Promise<ITokenResponse> {
   const req = await api.post<ITokenResponse>("/auth/register", data);
@@ -26,15 +22,30 @@ export async function register(data: IRegister): Promise<ITokenResponse> {
 }*/
 
 export async function changePassword(
-  data: IChangePassword,
+  data: IChangePassword
 ): Promise<IChangePassword> {
   const req = await api.post<IChangePassword>("/auth/change-password", data);
   return req.data;
 }
 
 export async function setupWorkspace(
-  data: ISetupWorkspace,
+  data: ISetupWorkspace
 ): Promise<ITokenResponse> {
   const req = await api.post<ITokenResponse>("/auth/setup", data);
   return req.data;
 }
+
+export async function forgotPassword(data: IForgotPassword): Promise<void> {
+  await api.post<any>("/auth/forgot-password", data);
+}
+
+export async function passwordReset(
+  data: IPasswordReset
+): Promise<ITokenResponse> {
+  const req = await api.post<any>("/auth/password-reset", data);
+  return req.data;
+}
+
+export async function verifyUserToken(data: IVerifyUserToken): Promise<any> {
+  return api.post<any>("/auth/verify-token", data);
+}

apps/client/src/features/auth/types/auth.types.ts

@@ -29,3 +29,17 @@ export interface IChangePassword {
   oldPassword: string;
   newPassword: string;
 }
+
+export interface IForgotPassword {
+  email: string;
+}
+
+export interface IPasswordReset {
+  token?: string;
+  newPassword: string;
+}
+
+export interface IVerifyUserToken {
+  token: string;
+  type: string;
+}

apps/client/src/features/editor/components/code-block/code-block-view.tsx

@@ -49,7 +49,7 @@ export default function CodeBlockView(props: NodeViewProps) {
         <Select
           placeholder="auto"
           checkIconPosition="right"
-          data={extension.options.lowlight.listLanguages()}
+          data={extension.options.lowlight.listLanguages().sort()}
           value={languageValue}
           onChange={changeLanguage}
           searchable

apps/client/src/features/editor/components/math/math.module.css

@@ -33,7 +33,7 @@
     border-radius: 4px;
     transition: background-color 0.2s;
     margin: 0 0.1rem;
-    overflow-x: scroll;
+    overflow-x: auto;
 
     .textInput {
         width: 400px;

apps/client/src/features/editor/components/slash-menu/menu-items.ts

@@ -16,7 +16,8 @@ import {
   IconPhoto,
   IconTable,
   IconTypography,
-  IconMenu4
+  IconMenu4,
+  IconCalendar,
 } from "@tabler/icons-react";
 import {
   CommandProps,
@@ -330,6 +331,26 @@ const CommandGroups: SlashMenuGroupedItemsType = {
       command: ({ editor, range }: CommandProps) =>
         editor.chain().focus().deleteRange(range).setExcalidraw().run(),
     },
+    {
+      title: "Date",
+      description: "Insert current date",
+      searchTerms: ["date", "today"],
+      icon: IconCalendar,
+      command: ({ editor, range }: CommandProps) => {
+        const currentDate = new Date().toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "long",
+          day: "numeric",
+        });
+
+        return editor
+          .chain()
+          .focus()
+          .deleteRange(range)
+          .insertContent(currentDate)
+          .run();
+      },
+    },
   ],
 };
 

apps/client/src/features/editor/extensions/extensions.ts

@@ -54,9 +54,26 @@ import CodeBlockView from "@/features/editor/components/code-block/code-block-vi
 import DrawioView from "../components/drawio/drawio-view";
 import ExcalidrawView from "@/features/editor/components/excalidraw/excalidraw-view.tsx";
 import plaintext from "highlight.js/lib/languages/plaintext";
+import powershell from "highlight.js/lib/languages/powershell";
+import elixir from "highlight.js/lib/languages/elixir";
+import erlang from "highlight.js/lib/languages/erlang";
+import dockerfile from "highlight.js/lib/languages/dockerfile";
+import clojure from "highlight.js/lib/languages/clojure";
+import fortran from "highlight.js/lib/languages/fortran";
+import haskell from "highlight.js/lib/languages/haskell";
+import scala from "highlight.js/lib/languages/scala";
 
 const lowlight = createLowlight(common);
 lowlight.register("mermaid", plaintext);
+lowlight.register("powershell", powershell);
+lowlight.register("powershell", powershell);
+lowlight.register("erlang", erlang);
+lowlight.register("elixir", elixir);
+lowlight.register("dockerfile", dockerfile);
+lowlight.register("clojure", clojure);
+lowlight.register("fortran", fortran);
+lowlight.register("haskell", haskell);
+lowlight.register("scala", scala);
 
 export const mainExtensions = [
   StarterKit.configure({

apps/client/src/features/group/queries/group-query.ts

@@ -3,8 +3,8 @@ import {
   useQuery,
   useQueryClient,
   UseQueryResult,
-} from "@tanstack/react-query";
+} from '@tanstack/react-query';
-import { IGroup } from "@/features/group/types/group.types";
+import { IGroup } from '@/features/group/types/group.types';
 import {
   addGroupMember,
   createGroup,
@@ -14,22 +14,22 @@ import {
   getGroups,
   removeGroupMember,
   updateGroup,
-} from "@/features/group/services/group-service";
+} from '@/features/group/services/group-service';
-import { notifications } from "@mantine/notifications";
+import { notifications } from '@mantine/notifications';
-import { QueryParams } from "@/lib/types.ts";
+import { QueryParams } from '@/lib/types.ts';
 
 export function useGetGroupsQuery(
-  params?: QueryParams,
+  params?: QueryParams
 ): UseQueryResult<any, Error> {
   return useQuery({
-    queryKey: ["groups", params],
+    queryKey: ['groups', params],
     queryFn: () => getGroups(params),
   });
 }
 
 export function useGroupQuery(groupId: string): UseQueryResult<IGroup, Error> {
   return useQuery({
-    queryKey: ["groups", groupId],
+    queryKey: ['groups', groupId],
     queryFn: () => getGroupById(groupId),
     enabled: !!groupId,
   });
@@ -37,7 +37,7 @@ export function useGroupQuery(groupId: string): UseQueryResult<IGroup, Error> {
 
 export function useGroupMembersQuery(groupId: string) {
   return useQuery({
-    queryKey: ["groupMembers", groupId],
+    queryKey: ['groupMembers', groupId],
     queryFn: () => getGroupMembers(groupId),
     enabled: !!groupId,
   });
@@ -47,10 +47,10 @@ export function useCreateGroupMutation() {
   return useMutation<IGroup, Error, Partial<IGroup>>({
     mutationFn: (data) => createGroup(data),
     onSuccess: () => {
-      notifications.show({ message: "Group created successfully" });
+      notifications.show({ message: 'Group created successfully' });
     },
     onError: () => {
-      notifications.show({ message: "Failed to create group", color: "red" });
+      notifications.show({ message: 'Failed to create group', color: 'red' });
     },
   });
 }
@@ -61,14 +61,14 @@ export function useUpdateGroupMutation() {
   return useMutation<IGroup, Error, Partial<IGroup>>({
     mutationFn: (data) => updateGroup(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Group updated successfully" });
+      notifications.show({ message: 'Group updated successfully' });
       queryClient.invalidateQueries({
-        queryKey: ["group", variables.groupId],
+        queryKey: ['group', variables.groupId],
       });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }
@@ -79,17 +79,19 @@ export function useDeleteGroupMutation() {
   return useMutation({
     mutationFn: (groupId: string) => deleteGroup({ groupId }),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Group deleted successfully" });
+      notifications.show({ message: 'Group deleted successfully' });
 
-      const groups = queryClient.getQueryData(["groups"]) as any;
+      const groups = queryClient.getQueryData(['groups']) as any;
       if (groups) {
-        groups.items?.filter((group: IGroup) => group.id !== variables);
+        groups.items = groups.items?.filter(
-        queryClient.setQueryData(["groups"], groups);
+          (group: IGroup) => group.id !== variables
+        );
+        queryClient.setQueryData(['groups'], groups);
       }
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }
@@ -100,15 +102,15 @@ export function useAddGroupMemberMutation() {
   return useMutation<void, Error, { groupId: string; userIds: string[] }>({
     mutationFn: (data) => addGroupMember(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Added successfully" });
+      notifications.show({ message: 'Added successfully' });
       queryClient.invalidateQueries({
-        queryKey: ["groupMembers", variables.groupId],
+        queryKey: ['groupMembers', variables.groupId],
       });
     },
     onError: () => {
       notifications.show({
-        message: "Failed to add group members",
+        message: 'Failed to add group members',
-        color: "red",
+        color: 'red',
       });
     },
   });
@@ -127,14 +129,14 @@ export function useRemoveGroupMemberMutation() {
   >({
     mutationFn: (data) => removeGroupMember(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Removed successfully" });
+      notifications.show({ message: 'Removed successfully' });
       queryClient.invalidateQueries({
-        queryKey: ["groupMembers", variables.groupId],
+        queryKey: ['groupMembers', variables.groupId],
       });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }

apps/client/src/features/page/services/page-service.ts

@@ -64,7 +64,7 @@ export async function exportPage(data: IExportPageParams): Promise<void> {
     .split("filename=")[1]
     .replace(/"/g, "");
 
-  saveAs(req.data, fileName);
+  saveAs(req.data, decodeURIComponent(fileName));
 }
 
 export async function importPage(file: File, spaceId: string) {
@@ -81,14 +81,17 @@ export async function importPage(file: File, spaceId: string) {
   return req.data;
 }
 
-export async function uploadFile(file: File, pageId: string, attachmentId?: string): Promise<IAttachment> {
+export async function uploadFile(
+  file: File,
+  pageId: string,
+  attachmentId?: string,
+): Promise<IAttachment> {
   const formData = new FormData();
-  if(attachmentId){
+  if (attachmentId) {
     formData.append("attachmentId", attachmentId);
   }
   formData.append("pageId", pageId);
   formData.append("file", file);
-  
 
   const req = await api.post<IAttachment>("/files/upload", formData, {
     headers: {

apps/client/src/features/space/components/delete-space-modal.tsx

@@ -0,0 +1,86 @@
+import { Button, Divider, Group, Modal, Text, TextInput } from '@mantine/core';
+import { useDisclosure } from '@mantine/hooks';
+import { useDeleteSpaceMutation } from '../queries/space-query';
+import { useField } from '@mantine/form';
+import { ISpace } from '../types/space.types';
+import { useNavigate } from 'react-router-dom';
+import APP_ROUTE from '@/lib/app-route';
+
+interface DeleteSpaceModalProps {
+  space: ISpace;
+}
+
+export default function DeleteSpaceModal({ space }: DeleteSpaceModalProps) {
+  const [opened, { open, close }] = useDisclosure(false);
+  const deleteSpaceMutation = useDeleteSpaceMutation();
+  const navigate = useNavigate();
+
+  const confirmNameField = useField({
+    initialValue: '',
+    validateOnChange: true,
+    validate: (value) =>
+      value.trim().toLowerCase() === space.name.trim().toLocaleLowerCase()
+        ? null
+        : 'Names do not match',
+  });
+
+  const handleDelete = async () => {
+    if (
+      confirmNameField.getValue().trim().toLowerCase() !==
+      space.name.trim().toLowerCase()
+    ) {
+      confirmNameField.validate();
+      return;
+    }
+
+    try {
+      // pass slug too so we can clear the local cache
+      await deleteSpaceMutation.mutateAsync({ id: space.id, slug: space.slug });
+      navigate(APP_ROUTE.HOME);
+    } catch (error) {
+      console.error('Failed to delete space', error);
+    }
+  };
+
+  return (
+    <>
+      <Button onClick={open} variant="light" color="red">
+        Delete
+      </Button>
+
+      <Modal
+        opened={opened}
+        onClose={close}
+        title="Are you sure you want to delete this space?"
+      >
+        <Divider size="xs" mb="xs" />
+        <Text>
+          All pages, comments, attachments and permissions in this space will be
+          deleted irreversibly.
+        </Text>
+        <Text mt="sm">
+          Type the space name{' '}
+          <Text span fw={500}>
+            '{space.name}'
+          </Text>{' '}
+          to confirm your action.
+        </Text>
+        <TextInput
+          {...confirmNameField.getInputProps()}
+          variant="filled"
+          placeholder="Confirm space name"
+          py="sm"
+          data-autofocus
+        />
+        <Group justify="flex-end" mt="md">
+          <Button onClick={close} variant="default">
+            Cancel
+          </Button>
+          <Button onClick={handleDelete} color="red">
+            Confirm
+          </Button>
+        </Group>
+      </Modal>
+    </>
+  );
+}

apps/client/src/features/space/components/edit-space-form.tsx

@@ -8,6 +8,14 @@ import { ISpace } from "@/features/space/types/space.types.ts";
 const formSchema = z.object({
   name: z.string().min(2).max(50),
   description: z.string().max(250),
+  slug: z
+    .string()
+    .min(2)
+    .max(50)
+    .regex(
+      /^[a-zA-Z0-9]+$/,
+      "Space slug must be alphanumeric. No special characters",
+    ),
 });
 
 type FormValues = z.infer<typeof formSchema>;
@@ -23,12 +31,14 @@ export function EditSpaceForm({ space, readOnly }: EditSpaceFormProps) {
     initialValues: {
       name: space?.name,
       description: space?.description || "",
+      slug: space.slug,
     },
   });
 
   const handleSubmit = async (values: {
     name?: string;
     description?: string;
+    slug?: string;
   }) => {
     const spaceData: Partial<ISpace> = {
       spaceId: space.id,
@@ -40,6 +50,10 @@ export function EditSpaceForm({ space, readOnly }: EditSpaceFormProps) {
       spaceData.description = values.description;
     }
 
+    if (form.isDirty("slug")) {
+      spaceData.slug = values.slug;
+    }
+
     await updateSpaceMutation.mutateAsync(spaceData);
     form.resetDirty();
   };
@@ -62,8 +76,8 @@ export function EditSpaceForm({ space, readOnly }: EditSpaceFormProps) {
               id="slug"
               label="Slug"
               variant="filled"
-              readOnly
+              readOnly={readOnly}
-              value={space.slug}
+              {...form.getInputProps("slug")}
             />
 
             <Textarea

apps/client/src/features/space/components/sidebar/space-name.module.css

@@ -1,6 +0,0 @@
-.spaceName {
-    display: block;
-    width: 100%;
-    padding: var(--mantine-spacing-sm);
-    color: light-dark(var(--mantine-color-black), var(--mantine-color-dark-0));
-  }

apps/client/src/features/space/components/sidebar/space-name.tsx

@@ -1,19 +0,0 @@
-import { UnstyledButton, Group, Text } from "@mantine/core";
-import classes from "./space-name.module.css";
-
-interface SpaceNameProps {
-  spaceName: string;
-}
-export function SpaceName({ spaceName }: SpaceNameProps) {
-  return (
-    <UnstyledButton className={classes.spaceName}>
-      <Group>
-        <div style={{ flex: 1 }}>
-          <Text size="md" fw={500} lineClamp={1}>
-            {spaceName}
-          </Text>
-        </div>
-      </Group>
-    </UnstyledButton>
-  );
-}

apps/client/src/features/space/components/sidebar/space-select.tsx

@@ -0,0 +1,70 @@
+import { useEffect, useState } from 'react';
+import { useDebouncedValue } from '@mantine/hooks';
+import { Avatar, Group, Select, SelectProps, Text } from '@mantine/core';
+import { useGetSpacesQuery } from '@/features/space/queries/space-query.ts';
+import { ISpace } from '../../types/space.types';
+
+interface SpaceSelectProps {
+  onChange: (value: string) => void;
+  value?: string;
+  label?: string;
+}
+
+const renderSelectOption: SelectProps['renderOption'] = ({ option }) => (
+  <Group gap="sm">
+    <Avatar color="initials" variant="filled" name={option.label} size={20} />
+    <div>
+      <Text size="sm">{option.label}</Text>
+    </div>
+  </Group>
+);
+
+export function SpaceSelect({ onChange, label, value }: SpaceSelectProps) {
+  const [searchValue, setSearchValue] = useState('');
+  const [debouncedQuery] = useDebouncedValue(searchValue, 500);
+  const { data: spaces, isLoading } = useGetSpacesQuery({
+    query: debouncedQuery,
+    limit: 50,
+  });
+  const [data, setData] = useState([]);
+
+  useEffect(() => {
+    if (spaces) {
+      const spaceData = spaces?.items
+        .filter((space: ISpace) => space.slug !== value)
+        .map((space: ISpace) => {
+          return {
+            label: space.name,
+            value: space.slug,
+          };
+        });
+
+      const filteredSpaceData = spaceData.filter(
+        (user) =>
+          !data.find((existingUser) => existingUser.value === user.value)
+      );
+      setData((prevData) => [...prevData, ...filteredSpaceData]);
+    }
+  }, [spaces]);
+
+  return (
+    <Select
+      data={data}
+      renderOption={renderSelectOption}
+      maxDropdownHeight={300}
+      //label={label || 'Select space'}
+      placeholder="Search for spaces"
+      searchable
+      searchValue={searchValue}
+      onSearchChange={setSearchValue}
+      clearable
+      variant="filled"
+      onChange={onChange}
+      nothingFoundMessage="No space found"
+      limit={50}
+      checkIconPosition="right"
+      comboboxProps={{ width: 300, withinPortal: false }}
+      dropdownOpened
+    />
+  );
+}

apps/client/src/features/space/components/sidebar/space-sidebar.tsx

@@ -5,8 +5,8 @@ import {
   Text,
   Tooltip,
   UnstyledButton,
-} from "@mantine/core";
+} from '@mantine/core';
-import { spotlight } from "@mantine/spotlight";
+import { spotlight } from '@mantine/spotlight';
 import {
   IconArrowDown,
   IconDots,
@@ -14,27 +14,27 @@ import {
   IconPlus,
   IconSearch,
   IconSettings,
-} from "@tabler/icons-react";
+} from '@tabler/icons-react';
 
-import classes from "./space-sidebar.module.css";
+import classes from './space-sidebar.module.css';
-import React, { useMemo } from "react";
+import React, { useMemo } from 'react';
-import { useAtom } from "jotai";
+import { useAtom } from 'jotai';
-import { SearchSpotlight } from "@/features/search/search-spotlight.tsx";
+import { SearchSpotlight } from '@/features/search/search-spotlight.tsx';
-import { treeApiAtom } from "@/features/page/tree/atoms/tree-api-atom.ts";
+import { treeApiAtom } from '@/features/page/tree/atoms/tree-api-atom.ts';
-import { Link, useLocation, useParams } from "react-router-dom";
+import { Link, useLocation, useParams } from 'react-router-dom';
-import clsx from "clsx";
+import clsx from 'clsx';
-import { useDisclosure } from "@mantine/hooks";
+import { useDisclosure } from '@mantine/hooks';
-import SpaceSettingsModal from "@/features/space/components/settings-modal.tsx";
+import SpaceSettingsModal from '@/features/space/components/settings-modal.tsx';
-import { useGetSpaceBySlugQuery } from "@/features/space/queries/space-query.ts";
+import { useGetSpaceBySlugQuery } from '@/features/space/queries/space-query.ts';
-import { SpaceName } from "@/features/space/components/sidebar/space-name.tsx";
+import { getSpaceUrl } from '@/lib/config.ts';
-import { getSpaceUrl } from "@/lib/config.ts";
+import SpaceTree from '@/features/page/tree/components/space-tree.tsx';
-import SpaceTree from "@/features/page/tree/components/space-tree.tsx";
+import { useSpaceAbility } from '@/features/space/permissions/use-space-ability.ts';
-import { useSpaceAbility } from "@/features/space/permissions/use-space-ability.ts";
 import {
   SpaceCaslAction,
   SpaceCaslSubject,
-} from "@/features/space/permissions/permissions.type.ts";
+} from '@/features/space/permissions/permissions.type.ts';
-import PageImportModal from "@/features/page/components/page-import-modal.tsx";
+import PageImportModal from '@/features/page/components/page-import-modal.tsx';
+import { SwitchSpace } from './switch-space';
 
 export function SpaceSidebar() {
   const [tree] = useAtom(treeApiAtom);
@@ -52,7 +52,7 @@ export function SpaceSidebar() {
   }
 
   function handleCreatePage() {
-    tree?.create({ parentId: null, type: "internal", index: 0 });
+    tree?.create({ parentId: null, type: 'internal', index: 0 });
   }
 
   return (
@@ -61,11 +61,12 @@ export function SpaceSidebar() {
         <div
           className={classes.section}
           style={{
-            border: "none",
+            border: 'none',
-            marginBottom: "0",
+            marginTop: 2,
+            marginBottom: 3,
           }}
         >
-          <SpaceName spaceName={space?.name} />
+          <SwitchSpace spaceName={space?.name} spaceSlug={space?.slug} />
         </div>
 
         <div className={classes.section}>
@@ -77,7 +78,7 @@ export function SpaceSidebar() {
                 classes.menu,
                 location.pathname.toLowerCase() === getSpaceUrl(spaceSlug)
                   ? classes.activeButton
-                  : "",
+                  : ''
               )}
             >
               <div className={classes.menuItemInner}>
@@ -114,7 +115,7 @@ export function SpaceSidebar() {
 
             {spaceAbility.can(
               SpaceCaslAction.Manage,
-              SpaceCaslSubject.Page,
+              SpaceCaslSubject.Page
             ) && (
               <UnstyledButton
                 className={classes.menu}
@@ -141,7 +142,7 @@ export function SpaceSidebar() {
 
             {spaceAbility.can(
               SpaceCaslAction.Manage,
-              SpaceCaslSubject.Page,
+              SpaceCaslSubject.Page
             ) && (
               <Group gap="xs">
                 <SpaceMenu spaceId={space.id} onSpaceSettings={openSettings} />
@@ -165,7 +166,7 @@ export function SpaceSidebar() {
               spaceId={space.id}
               readOnly={spaceAbility.cannot(
                 SpaceCaslAction.Manage,
-                SpaceCaslSubject.Page,
+                SpaceCaslSubject.Page
               )}
             />
           </div>

apps/client/src/features/space/components/sidebar/switch-space.module.css

@@ -0,0 +1,5 @@
+.spaceName {
+  width: 100%;
+  padding: var(--mantine-spacing-sm);
+  color: light-dark(var(--mantine-color-dark-4), var(--mantine-color-dark-0));
+}

apps/client/src/features/space/components/sidebar/switch-space.tsx

@@ -0,0 +1,62 @@
+import classes from './switch-space.module.css';
+import { useNavigate } from 'react-router-dom';
+import { SpaceSelect } from './space-select';
+import { getSpaceUrl } from '@/lib/config';
+import { Avatar, Button, Popover, Text } from '@mantine/core';
+import { IconChevronDown } from '@tabler/icons-react';
+import { useDisclosure } from '@mantine/hooks';
+
+interface SwitchSpaceProps {
+  spaceName: string;
+  spaceSlug: string;
+}
+
+export function SwitchSpace({ spaceName, spaceSlug }: SwitchSpaceProps) {
+  const [opened, { close, open, toggle }] = useDisclosure(false);
+  const navigate = useNavigate();
+
+  const handleSelect = (value: string) => {
+    if (value) {
+      navigate(getSpaceUrl(value));
+      close();
+    }
+  };
+
+  return (
+    <Popover
+      width={300}
+      position="bottom"
+      withArrow
+      shadow="md"
+      opened={opened}
+    >
+      <Popover.Target>
+        <Button
+          variant="subtle"
+          fullWidth
+          justify="space-between"
+          rightSection={<IconChevronDown size={18} />}
+          color="gray"
+          onClick={toggle}
+        >
+          <Avatar
+            size={20}
+            color="initials"
+            variant="filled"
+            name={spaceName}
+          />
+          <Text className={classes.spaceName} size="md" fw={500} lineClamp={1}>
+            {spaceName}
+          </Text>
+        </Button>
+      </Popover.Target>
+      <Popover.Dropdown>
+        <SpaceSelect
+          label={spaceName}
+          value={spaceSlug}
+          onChange={handleSelect}
+        />
+      </Popover.Dropdown>
+    </Popover>
+  );
+}

apps/client/src/features/space/components/space-details.tsx

@@ -1,7 +1,8 @@
-import React from "react";
+import React from 'react';
-import { useSpaceQuery } from "@/features/space/queries/space-query.ts";
+import { useSpaceQuery } from '@/features/space/queries/space-query.ts';
-import { EditSpaceForm } from "@/features/space/components/edit-space-form.tsx";
+import { EditSpaceForm } from '@/features/space/components/edit-space-form.tsx';
-import { Text } from "@mantine/core";
+import { Divider, Group, Text } from '@mantine/core';
+import DeleteSpaceModal from './delete-space-modal';
 
 interface SpaceDetailsProps {
   spaceId: string;
@@ -18,6 +19,23 @@ export default function SpaceDetails({ spaceId, readOnly }: SpaceDetailsProps) {
             Details
           </Text>
           <EditSpaceForm space={space} readOnly={readOnly} />
+
+          {!readOnly && (
+            <>
+              <Divider my="lg" />
+
+              <Group justify="space-between" wrap="nowrap" gap="xl">
+                <div>
+                  <Text size="md">Delete space</Text>
+                  <Text size="sm" c="dimmed">
+                    Delete this space with all its pages and data.
+                  </Text>
+                </div>
+
+                <DeleteSpaceModal space={space} />
+              </Group>
+            </>
+          )}
         </div>
       )}
     </>

apps/client/src/features/space/queries/space-query.ts

@@ -3,14 +3,14 @@ import {
   useQuery,
   useQueryClient,
   UseQueryResult,
-} from "@tanstack/react-query";
+} from '@tanstack/react-query';
 import {
   IAddSpaceMember,
   IChangeSpaceMemberRole,
   IRemoveSpaceMember,
   ISpace,
   ISpaceMember,
-} from "@/features/space/types/space.types";
+} from '@/features/space/types/space.types';
 import {
   addSpaceMember,
   changeMemberRole,
@@ -20,23 +20,23 @@ import {
   removeSpaceMember,
   createSpace,
   updateSpace,
-} from "@/features/space/services/space-service.ts";
+  deleteSpace,
-import { notifications } from "@mantine/notifications";
+} from '@/features/space/services/space-service.ts';
-import { IPagination } from "@/lib/types.ts";
+import { notifications } from '@mantine/notifications';
+import { IPagination, QueryParams } from '@/lib/types.ts';
 
-export function useGetSpacesQuery(): UseQueryResult<
+export function useGetSpacesQuery(
-  IPagination<ISpace>,
+  params?: QueryParams
-  Error
+): UseQueryResult<IPagination<ISpace>, Error> {
-> {
   return useQuery({
-    queryKey: ["spaces"],
+    queryKey: ['spaces', params],
-    queryFn: () => getSpaces(),
+    queryFn: () => getSpaces(params),
   });
 }
 
 export function useSpaceQuery(spaceId: string): UseQueryResult<ISpace, Error> {
   return useQuery({
-    queryKey: ["spaces", spaceId],
+    queryKey: ['spaces', spaceId],
     queryFn: () => getSpaceById(spaceId),
     enabled: !!spaceId,
     staleTime: 5 * 60 * 1000,
@@ -50,22 +50,22 @@ export function useCreateSpaceMutation() {
     mutationFn: (data) => createSpace(data),
     onSuccess: () => {
       queryClient.invalidateQueries({
-        queryKey: ["spaces"],
+        queryKey: ['spaces'],
       });
-      notifications.show({ message: "Space created successfully" });
+      notifications.show({ message: 'Space created successfully' });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }
 
 export function useGetSpaceBySlugQuery(
-  spaceId: string,
+  spaceId: string
 ): UseQueryResult<ISpace, Error> {
   return useQuery({
-    queryKey: ["spaces", spaceId],
+    queryKey: ['spaces', spaceId],
     queryFn: () => getSpaceById(spaceId),
     enabled: !!spaceId,
     staleTime: 5 * 60 * 1000,
@@ -78,34 +78,64 @@ export function useUpdateSpaceMutation() {
   return useMutation<ISpace, Error, Partial<ISpace>>({
     mutationFn: (data) => updateSpace(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Space updated successfully" });
+      notifications.show({ message: 'Space updated successfully' });
 
       const space = queryClient.getQueryData([
-        "space",
+        'space',
         variables.spaceId,
       ]) as ISpace;
       if (space) {
         const updatedSpace = { ...space, ...data };
-        queryClient.setQueryData(["space", variables.spaceId], updatedSpace);
+        queryClient.setQueryData(['space', variables.spaceId], updatedSpace);
-        queryClient.setQueryData(["space", data.slug], updatedSpace);
+        queryClient.setQueryData(['space', data.slug], updatedSpace);
       }
 
       queryClient.invalidateQueries({
-        queryKey: ["spaces"],
+        queryKey: ['spaces'],
       });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
+    },
+  });
+}
+
+export function useDeleteSpaceMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: Partial<ISpace>) => deleteSpace(data.id),
+    onSuccess: (data, variables) => {
+      notifications.show({ message: 'Space deleted successfully' });
+
+      if (variables.slug) {
+        queryClient.removeQueries({
+          queryKey: ['spaces', variables.slug],
+          exact: true,
+        });
+      }
+
+      const spaces = queryClient.getQueryData(['spaces']) as any;
+      if (spaces) {
+        spaces.items = spaces.items?.filter(
+          (space: ISpace) => space.id !== variables.id
+        );
+        queryClient.setQueryData(['spaces'], spaces);
+      }
+    },
+    onError: (error) => {
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }
 
 export function useSpaceMembersQuery(
-  spaceId: string,
+  spaceId: string
 ): UseQueryResult<IPagination<ISpaceMember>, Error> {
   return useQuery({
-    queryKey: ["spaceMembers", spaceId],
+    queryKey: ['spaceMembers', spaceId],
     queryFn: () => getSpaceMembers(spaceId),
     enabled: !!spaceId,
   });
@@ -117,14 +147,14 @@ export function useAddSpaceMemberMutation() {
   return useMutation<void, Error, IAddSpaceMember>({
     mutationFn: (data) => addSpaceMember(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Members added successfully" });
+      notifications.show({ message: 'Members added successfully' });
       queryClient.invalidateQueries({
-        queryKey: ["spaceMembers", variables.spaceId],
+        queryKey: ['spaceMembers', variables.spaceId],
       });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }
@@ -135,14 +165,14 @@ export function useRemoveSpaceMemberMutation() {
   return useMutation<void, Error, IRemoveSpaceMember>({
     mutationFn: (data) => removeSpaceMember(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Removed successfully" });
+      notifications.show({ message: 'Removed successfully' });
       queryClient.refetchQueries({
-        queryKey: ["spaceMembers", variables.spaceId],
+        queryKey: ['spaceMembers', variables.spaceId],
       });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }
@@ -153,15 +183,15 @@ export function useChangeSpaceMemberRoleMutation() {
   return useMutation<void, Error, IChangeSpaceMemberRole>({
     mutationFn: (data) => changeMemberRole(data),
     onSuccess: (data, variables) => {
-      notifications.show({ message: "Member role updated successfully" });
+      notifications.show({ message: 'Member role updated successfully' });
       // due to pagination levels, change in cache instead
       queryClient.refetchQueries({
-        queryKey: ["spaceMembers", variables.spaceId],
+        queryKey: ['spaceMembers', variables.spaceId],
       });
     },
     onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
+      const errorMessage = error['response']?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      notifications.show({ message: errorMessage, color: 'red' });
     },
   });
 }

apps/client/src/features/space/services/space-service.ts

@@ -1,52 +1,56 @@
-import api from "@/lib/api-client";
+import api from '@/lib/api-client';
 import {
   IAddSpaceMember,
   IChangeSpaceMemberRole,
   IRemoveSpaceMember,
   ISpace,
 } from "@/features/space/types/space.types";
-import { IPagination } from "@/lib/types.ts";
+import { IPagination, QueryParams } from "@/lib/types.ts";
 import { IUser } from "@/features/user/types/user.types.ts";
 
-export async function getSpaces(): Promise<IPagination<ISpace>> {
+export async function getSpaces(params?: QueryParams): Promise<IPagination<ISpace>> {
-  const req = await api.post("/spaces");
+  const req = await api.post("/spaces", params);
   return req.data;
 }
 
 export async function getSpaceById(spaceId: string): Promise<ISpace> {
-  const req = await api.post<ISpace>("/spaces/info", { spaceId });
+  const req = await api.post<ISpace>('/spaces/info', { spaceId });
   return req.data;
 }
 
 export async function createSpace(data: Partial<ISpace>): Promise<ISpace> {
-  const req = await api.post<ISpace>("/spaces/create", data);
+  const req = await api.post<ISpace>('/spaces/create', data);
   return req.data;
 }
 
 export async function updateSpace(data: Partial<ISpace>): Promise<ISpace> {
-  const req = await api.post<ISpace>("/spaces/update", data);
+  const req = await api.post<ISpace>('/spaces/update', data);
   return req.data;
 }
 
+export async function deleteSpace(spaceId: string): Promise<void> {
+  await api.post<void>('/spaces/delete', { spaceId });
+}
+
 export async function getSpaceMembers(
-  spaceId: string,
+  spaceId: string
 ): Promise<IPagination<IUser>> {
-  const req = await api.post<any>("/spaces/members", { spaceId });
+  const req = await api.post<any>('/spaces/members', { spaceId });
   return req.data;
 }
 
 export async function addSpaceMember(data: IAddSpaceMember): Promise<void> {
-  await api.post("/spaces/members/add", data);
+  await api.post('/spaces/members/add', data);
 }
 
 export async function removeSpaceMember(
-  data: IRemoveSpaceMember,
+  data: IRemoveSpaceMember
 ): Promise<void> {
-  await api.post("/spaces/members/remove", data);
+  await api.post('/spaces/members/remove', data);
 }
 
 export async function changeMemberRole(
-  data: IChangeSpaceMemberRole,
+  data: IChangeSpaceMemberRole
 ): Promise<void> {
-  await api.post("/spaces/members/change-role", data);
+  await api.post('/spaces/members/change-role', data);
 }

apps/client/src/lib/app-route.ts

@@ -4,6 +4,8 @@ const APP_ROUTE = {
     LOGIN: "/login",
     SIGNUP: "/signup",
     SETUP: "/setup/register",
+    FORGOT_PASSWORD: "/forgot-password",
+    PASSWORD_RESET: "/password-reset",
   },
   SETTINGS: {
     ACCOUNT: {

apps/client/src/lib/config.ts

@@ -7,23 +7,27 @@ declare global {
 export function getAppUrl(): string {
   //let appUrl = window.CONFIG?.APP_URL || process.env.APP_URL;
 
- // if (import.meta.env.DEV) {
+  // if (import.meta.env.DEV) {
- //   return appUrl || "http://localhost:3000";
+  //   return appUrl || "http://localhost:3000";
   //}
 
   return `${window.location.protocol}//${window.location.host}`;
 }
 
 export function getBackendUrl(): string {
-  return getAppUrl() + "/api";
+  return getAppUrl() + '/api';
 }
 
 export function getCollaborationUrl(): string {
-  const COLLAB_PATH = "/collab";
+  const COLLAB_PATH = '/collab';
-  const url = process.env.APP_URL || getAppUrl();
 
-  const wsProtocol = url.startsWith("https") ? "wss" : "ws";
+  let url = getAppUrl();
-  return `${wsProtocol}://${url.split("://")[1]}${COLLAB_PATH}`;
+  if (import.meta.env.DEV) {
+    url = process.env.APP_URL;
+  }
+
+  const wsProtocol = url.startsWith('https') ? 'wss' : 'ws';
+  return `${wsProtocol}://${url.split('://')[1]}${COLLAB_PATH}`;
 }
 
 export function getAvatarUrl(avatarUrl: string) {
@@ -31,17 +35,17 @@ export function getAvatarUrl(avatarUrl: string) {
     return null;
   }
 
-  if (avatarUrl?.startsWith("http")) {
+  if (avatarUrl?.startsWith('http')) {
     return avatarUrl;
   }
 
-  return getBackendUrl() + "/attachments/img/avatar/" + avatarUrl;
+  return getBackendUrl() + '/attachments/img/avatar/' + avatarUrl;
 }
 
 export function getSpaceUrl(spaceSlug: string) {
-  return "/s/" + spaceSlug;
+  return '/s/' + spaceSlug;
 }
 
 export function getFileUrl(src: string) {
-  return src?.startsWith("/files/") ? getBackendUrl() + src : src;
+  return src?.startsWith('/files/') ? getBackendUrl() + src : src;
 }

apps/client/src/pages/auth/forgot-password.tsx

@@ -0,0 +1,13 @@
+import { ForgotPasswordForm } from "@/features/auth/components/forgot-password-form";
+import { Helmet } from "react-helmet-async";
+
+export default function ForgotPassword() {
+    return (
+        <>
+            <Helmet>
+                <title>Forgot Password - Docmost</title>
+            </Helmet>
+            <ForgotPasswordForm />
+        </>
+    );
+}

apps/client/src/pages/auth/invite-signup.tsx

@@ -5,7 +5,7 @@ export default function InviteSignup() {
   return (
     <>
       <Helmet>
-        <title>Invitation signup</title>
+        <title>Invitation Signup - Docmost</title>
       </Helmet>
       <InviteSignUpForm />
     </>

apps/client/src/pages/auth/login.tsx

@@ -1,28 +1,13 @@
 import { LoginForm } from "@/features/auth/components/login-form";
-import useAuth from "@/features/auth/hooks/use-auth";
-import { useEffect } from "react";
 import { Helmet } from "react-helmet-async";
 
-
-const ntlmAuth = import.meta.env.VITE_NTLM_AUTH;
-
 export default function LoginPage() {
-  
-  const { ntlmSignIn } = useAuth();
-
-  useEffect(() => {
-
-    if (ntlmAuth)
-      ntlmSignIn();
-
-  }, [])
-
   return (
     <>
       <Helmet>
-        <title>Login</title>
+        <title>Login - Docmost</title>
       </Helmet>
-      {!ntlmAuth && <LoginForm />}
+      <LoginForm />
     </>
   );
 }

apps/client/src/pages/auth/password-reset.tsx

@@ -0,0 +1,53 @@
+import { Helmet } from "react-helmet-async";
+import { PasswordResetForm } from "@/features/auth/components/password-reset-form";
+import { Link, useSearchParams } from "react-router-dom";
+import { useVerifyUserTokenQuery } from "@/features/auth/queries/auth-query";
+import { Button, Container, Group, Text } from "@mantine/core";
+import APP_ROUTE from "@/lib/app-route";
+
+export default function PasswordReset() {
+  const [searchParams] = useSearchParams();
+  const { data, isLoading, isError } = useVerifyUserTokenQuery({
+    token: searchParams.get("token"),
+    type: "forgot-password",
+  });
+  const resetToken = searchParams.get("token");
+
+  if (isLoading) {
+    return <div></div>;
+  }
+
+  if (isError || !resetToken) {
+    return (
+      <>
+        <Helmet>
+          <title>Password Reset - Docmost</title>
+        </Helmet>
+        <Container my={40}>
+          <Text size="lg" ta="center">
+            Invalid or expired password reset link
+          </Text>
+          <Group justify="center">
+            <Button
+              component={Link}
+              to={APP_ROUTE.AUTH.LOGIN}
+              variant="subtle"
+              size="md"
+            >
+              Goto login page
+            </Button>
+          </Group>
+        </Container>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <Helmet>
+        <title>Password Reset - Docmost</title>
+      </Helmet>
+      <PasswordResetForm resetToken={resetToken} />
+    </>
+  );
+}

apps/client/src/pages/auth/setup-workspace.tsx

@@ -32,7 +32,7 @@ export default function SetupWorkspace() {
     return (
       <>
         <Helmet>
-          <title>Setup workspace</title>
+          <title>Setup Workspace - Docmost</title>
         </Helmet>
         <SetupWorkspaceForm />
       </>

apps/client/src/theme.ts

@@ -1,20 +1,34 @@
-import { createTheme, MantineColorsTuple } from "@mantine/core";
+import { createTheme, MantineColorsTuple } from '@mantine/core';
 
 const blue: MantineColorsTuple = [
-  "#e7f3ff",
+  '#e7f3ff',
-  "#d0e4ff",
+  '#d0e4ff',
-  "#a1c6fa",
+  '#a1c6fa',
-  "#6ea6f6",
+  '#6ea6f6',
-  "#458bf2",
+  '#458bf2',
-  "#2b7af1",
+  '#2b7af1',
-  "#0b60d8", //
+  '#0b60d8',
-  "#1b72f2",
+  '#1b72f2',
-  "#0056c1",
+  '#0056c1',
-  "#004aac",
+  '#004aac',
+];
+
+const red: MantineColorsTuple = [
+  '#ffebeb',
+  '#fad7d7',
+  '#eeadad',
+  '#e3807f',
+  '#da5a59',
+  '#d54241',
+  '#d43535',
+  '#bc2727',
+  '#a82022',
+  '#93151b',
 ];
 
 export const theme = createTheme({
   colors: {
     blue,
+    red,
   },
 });

apps/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "server",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "",
   "author": "",
   "private": true,
@@ -59,13 +59,11 @@
     "happy-dom": "^15.7.3",
     "kysely": "^0.27.4",
     "kysely-migration-cli": "^0.4.2",
-    "ldapjs": "^3.0.7",
     "marked": "^13.0.3",
     "mime-types": "^2.1.35",
     "nanoid": "^5.0.7",
     "nestjs-kysely": "^1.0.0",
     "nodemailer": "^6.9.14",
-    "ntlm-server": "^0.1.3",
     "passport-jwt": "^4.0.1",
     "pg": "^8.12.0",
     "pg-tsquery": "^8.4.2",
@@ -87,7 +85,6 @@
     "@types/debounce": "^1.2.4",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.12",
-    "@types/ldapjs": "^3.0.6",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^22.5.2",
     "@types/nodemailer": "^6.4.15",

apps/server/src/app.module.ts

@@ -14,7 +14,6 @@ import { EventEmitterModule } from '@nestjs/event-emitter';
 import { HealthModule } from './integrations/health/health.module';
 import { ExportModule } from './integrations/export/export.module';
 import { ImportModule } from './integrations/import/import.module';
-import { NTLMModule } from './integrations/ntlm/ntlm.module';
 
 @Module({
   imports: [
@@ -28,7 +27,6 @@ import { NTLMModule } from './integrations/ntlm/ntlm.module';
     HealthModule,
     ImportModule,
     ExportModule,
-    NTLMModule,
     StorageModule.forRootAsync({
       imports: [EnvironmentModule],
     }),

apps/server/src/common/events/event.contants.ts

@@ -0,0 +1,3 @@
+export enum EventName {
+  COLLAB_PAGE_UPDATED = 'collab.page.updated',
+}

apps/server/src/common/helpers/prosemirror/html/generateJSON.ts

@@ -1,7 +1,9 @@
 import { Extensions, getSchema } from '@tiptap/core';
 import { DOMParser, ParseOptions } from '@tiptap/pm/model';
-import { Window, DOMParser as HappyDomParser } from 'happy-dom';
+import { Window } from 'happy-dom';
 
+// this function does not work as intended
+// it has issues with closing tags
 export function generateJSON(
   html: string,
   extensions: Extensions,
@@ -10,8 +12,10 @@ export function generateJSON(
   const schema = getSchema(extensions);
 
   const window = new Window();
-  const dom = new HappyDomParser().parseFromString(html, 'text/html').body;
+  const document = window.document;
+  document.body.innerHTML = html;
 
-  // @ts-ignore
+  return DOMParser.fromSchema(schema)
-  return DOMParser.fromSchema(schema).parse(dom, options).toJSON();
+    .parse(document as never, options)
+    .toJSON();
 }

apps/server/src/core/attachment/attachment.controller.ts

@@ -182,7 +182,7 @@ export class AttachmentController {
       if (!inlineFileExtensions.includes(attachment.fileExt)) {
         res.header(
           'Content-Disposition',
-          `attachment; filename="${attachment.fileName}"`,
+          `attachment; filename="${encodeURIComponent(attachment.fileName)}"`,
         );
       }
 

apps/server/src/core/attachment/attachment.module.ts

@@ -4,10 +4,11 @@ import { AttachmentController } from './attachment.controller';
 import { StorageModule } from '../../integrations/storage/storage.module';
 import { UserModule } from '../user/user.module';
 import { WorkspaceModule } from '../workspace/workspace.module';
+import { AttachmentProcessor } from './processors/attachment.processor';
 
 @Module({
   imports: [StorageModule, UserModule, WorkspaceModule],
   controllers: [AttachmentController],
-  providers: [AttachmentService],
+  providers: [AttachmentService, AttachmentProcessor],
 })
 export class AttachmentModule {}

apps/server/src/core/attachment/processors/attachment.processor.ts

@@ -0,0 +1,47 @@
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import { OnWorkerEvent, Processor, WorkerHost } from '@nestjs/bullmq';
+import { Job } from 'bullmq';
+import { AttachmentService } from '../services/attachment.service';
+import { QueueJob, QueueName } from 'src/integrations/queue/constants';
+import { Space } from '@docmost/db/types/entity.types';
+
+@Processor(QueueName.ATTACHEMENT_QUEUE)
+export class AttachmentProcessor extends WorkerHost implements OnModuleDestroy {
+  private readonly logger = new Logger(AttachmentProcessor.name);
+  constructor(private readonly attachmentService: AttachmentService) {
+    super();
+  }
+
+  async process(job: Job<Space, void>): Promise<void> {
+    try {
+      if (job.name === QueueJob.DELETE_SPACE_ATTACHMENTS) {
+        await this.attachmentService.handleDeleteSpaceAttachments(job.data.id);
+      }
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  @OnWorkerEvent('active')
+  onActive(job: Job) {
+    this.logger.debug(`Processing ${job.name} job`);
+  }
+
+  @OnWorkerEvent('failed')
+  onError(job: Job) {
+    this.logger.error(
+      `Error processing ${job.name} job. Reason: ${job.failedReason}`,
+    );
+  }
+
+  @OnWorkerEvent('completed')
+  onCompleted(job: Job) {
+    this.logger.debug(`Completed ${job.name} job`);
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    if (this.worker) {
+      await this.worker.close();
+    }
+  }
+}

apps/server/src/core/attachment/services/attachment.service.ts

@@ -256,4 +256,37 @@ export class AttachmentService {
       trx,
     );
   }
+
+  async handleDeleteSpaceAttachments(spaceId: string) {
+    try {
+      const attachments = await this.attachmentRepo.findBySpaceId(spaceId);
+      if (!attachments || attachments.length === 0) {
+        return;
+      }
+
+      const failedDeletions = [];
+
+      await Promise.all(
+        attachments.map(async (attachment) => {
+          try {
+            await this.storageService.delete(attachment.filePath);
+            await this.attachmentRepo.deleteAttachmentById(attachment.id);
+          } catch (err) {
+            failedDeletions.push(attachment.id);
+            this.logger.log(
+              `DeleteSpaceAttachments: failed to delete attachment ${attachment.id}:`,
+              err,
+            );
+          }
+        }),
+      );
+
+      if(failedDeletions.length === attachments.length){
+        throw new Error(`Failed to delete any attachments for spaceId: ${spaceId}`);
+      }
+
+    } catch (err) {
+      throw err;
+    }
+  }
 }

apps/server/src/core/auth/auth.constants.ts

@@ -0,0 +1,3 @@
+export enum UserTokenType {
+  FORGOT_PASSWORD = 'forgot-password',
+}

apps/server/src/core/auth/auth.controller.ts

@@ -10,7 +10,6 @@ import {
 } from '@nestjs/common';
 import { LoginDto } from './dto/login.dto';
 import { AuthService } from './services/auth.service';
-import { CreateUserDto } from './dto/create-user.dto';
 import { SetupGuard } from './guards/setup.guard';
 import { EnvironmentService } from '../../integrations/environment/environment.service';
 import { CreateAdminUserDto } from './dto/create-admin-user.dto';
@@ -19,6 +18,9 @@ import { AuthUser } from '../../common/decorators/auth-user.decorator';
 import { User, Workspace } from '@docmost/db/types/entity.types';
 import { AuthWorkspace } from '../../common/decorators/auth-workspace.decorator';
 import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
+import { ForgotPasswordDto } from './dto/forgot-password.dto';
+import { PasswordResetDto } from './dto/password-reset.dto';
+import { VerifyUserTokenDto } from './dto/verify-user-token.dto';
 
 @Controller('auth')
 export class AuthController {
@@ -61,4 +63,31 @@ export class AuthController {
   ) {
     return this.authService.changePassword(dto, user.id, workspace.id);
   }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('forgot-password')
+  async forgotPassword(
+    @Body() forgotPasswordDto: ForgotPasswordDto,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.authService.forgotPassword(forgotPasswordDto, workspace.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('password-reset')
+  async passwordReset(
+    @Body() passwordResetDto: PasswordResetDto,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.authService.passwordReset(passwordResetDto, workspace.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('verify-token')
+  async verifyResetToken(
+    @Body() verifyUserTokenDto: VerifyUserTokenDto,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.authService.verifyUserToken(verifyUserTokenDto, workspace.id);
+  }
 }

apps/server/src/core/auth/auth.module.ts

@@ -10,6 +10,5 @@ import { TokenModule } from './token.module';
   imports: [TokenModule, WorkspaceModule],
   controllers: [AuthController],
   providers: [AuthService, SignupService, JwtStrategy],
-  exports: [AuthService]
 })
 export class AuthModule {}

apps/server/src/core/auth/dto/forgot-password.dto.ts

@@ -0,0 +1,7 @@
+import { IsEmail, IsNotEmpty } from 'class-validator';
+
+export class ForgotPasswordDto {
+  @IsNotEmpty()
+  @IsEmail()
+  email: string;
+}

apps/server/src/core/auth/dto/password-reset.dto.ts

@@ -0,0 +1,10 @@
+import { IsString, MinLength } from 'class-validator';
+
+export class PasswordResetDto {
+  @IsString()
+  token: string;
+
+  @IsString()
+  @MinLength(8)
+  newPassword: string;
+}

apps/server/src/core/auth/dto/verify-user-token.dto.ts

@@ -0,0 +1,9 @@
+import { IsString, MinLength } from 'class-validator';
+
+export class VerifyUserTokenDto {
+  @IsString()
+  token: string;
+
+  @IsString()
+  type: string;
+}

apps/server/src/core/auth/services/auth.service.ts

@@ -11,10 +11,25 @@ import { TokensDto } from '../dto/tokens.dto';
 import { SignupService } from './signup.service';
 import { CreateAdminUserDto } from '../dto/create-admin-user.dto';
 import { UserRepo } from '@docmost/db/repos/user/user.repo';
-import { comparePasswordHash, hashPassword } from '../../../common/helpers';
+import {
+  comparePasswordHash,
+  hashPassword,
+  nanoIdGen,
+} from '../../../common/helpers';
 import { ChangePasswordDto } from '../dto/change-password.dto';
 import { MailService } from '../../../integrations/mail/mail.service';
 import ChangePasswordEmail from '@docmost/transactional/emails/change-password-email';
+import { ForgotPasswordDto } from '../dto/forgot-password.dto';
+import ForgotPasswordEmail from '@docmost/transactional/emails/forgot-password-email';
+import { UserTokenRepo } from '@docmost/db/repos/user-token/user-token.repo';
+import { PasswordResetDto } from '../dto/password-reset.dto';
+import { UserToken } from '@docmost/db/types/entity.types';
+import { UserTokenType } from '../auth.constants';
+import { KyselyDB } from '@docmost/db/types/kysely.types';
+import { InjectKysely } from 'nestjs-kysely';
+import { executeTx } from '@docmost/db/utils';
+import { VerifyUserTokenDto } from '../dto/verify-user-token.dto';
+import { EnvironmentService } from 'src/integrations/environment/environment.service';
 
 @Injectable()
 export class AuthService {
@@ -22,7 +37,10 @@ export class AuthService {
     private signupService: SignupService,
     private tokenService: TokenService,
     private userRepo: UserRepo,
+    private userTokenRepo: UserTokenRepo,
     private mailService: MailService,
+    private environmentService: EnvironmentService,
+    @InjectKysely() private readonly db: KyselyDB,
   ) {}
 
   async login(loginDto: LoginDto, workspaceId: string) {
@@ -100,4 +118,108 @@ export class AuthService {
       template: emailTemplate,
     });
   }
+
+  async forgotPassword(
+    forgotPasswordDto: ForgotPasswordDto,
+    workspaceId: string,
+  ): Promise<void> {
+    const user = await this.userRepo.findByEmail(
+      forgotPasswordDto.email,
+      workspaceId,
+    );
+
+    if (!user) {
+      return;
+    }
+
+    const token = nanoIdGen(16);
+    const resetLink = `${this.environmentService.getAppUrl()}/password-reset?token=${token}`;
+
+    await this.userTokenRepo.insertUserToken({
+      token: token,
+      userId: user.id,
+      workspaceId: user.workspaceId,
+      expiresAt: new Date(new Date().getTime() + 60 * 60 * 1000), // 1 hour
+      type: UserTokenType.FORGOT_PASSWORD,
+    });
+
+    const emailTemplate = ForgotPasswordEmail({
+      username: user.name,
+      resetLink: resetLink,
+    });
+
+    await this.mailService.sendToQueue({
+      to: user.email,
+      subject: 'Reset your password',
+      template: emailTemplate,
+    });
+  }
+
+  async passwordReset(passwordResetDto: PasswordResetDto, workspaceId: string) {
+    const userToken = await this.userTokenRepo.findById(
+      passwordResetDto.token,
+      workspaceId,
+    );
+
+    if (
+      !userToken ||
+      userToken.type !== UserTokenType.FORGOT_PASSWORD ||
+      userToken.expiresAt < new Date()
+    ) {
+      throw new BadRequestException('Invalid or expired token');
+    }
+
+    const user = await this.userRepo.findById(userToken.userId, workspaceId);
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const newPasswordHash = await hashPassword(passwordResetDto.newPassword);
+
+    await executeTx(this.db, async (trx) => {
+      await this.userRepo.updateUser(
+        {
+          password: newPasswordHash,
+        },
+        user.id,
+        workspaceId,
+        trx,
+      );
+
+      trx
+        .deleteFrom('userTokens')
+        .where('userId', '=', user.id)
+        .where('type', '=', UserTokenType.FORGOT_PASSWORD)
+        .execute();
+    });
+
+    const emailTemplate = ChangePasswordEmail({ username: user.name });
+    await this.mailService.sendToQueue({
+      to: user.email,
+      subject: 'Your password has been changed',
+      template: emailTemplate,
+    });
+
+    const tokens: TokensDto = await this.tokenService.generateTokens(user);
+
+    return { tokens };
+  }
+
+  async verifyUserToken(
+    userTokenDto: VerifyUserTokenDto,
+    workspaceId: string,
+  ): Promise<void> {
+    const userToken = await this.userTokenRepo.findById(
+      userTokenDto.token,
+      workspaceId,
+    );
+
+    if (
+      !userToken ||
+      userToken.type !== userTokenDto.type ||
+      userToken.expiresAt < new Date()
+    ) {
+      throw new BadRequestException('Invalid or expired token');
+    }
+  }
 }

apps/server/src/core/auth/services/token.service.ts

@@ -31,7 +31,7 @@ export class TokenService {
       workspaceId,
       type: JwtType.REFRESH,
     };
-    const expiresIn = '30d'; // todo: fix
+    const expiresIn = this.environmentService.getJwtTokenExpiresIn();
     return this.jwtService.sign(payload, { expiresIn });
   }
 

apps/server/src/core/space/services/space.service.ts

@@ -14,6 +14,9 @@ import { executeTx } from '@docmost/db/utils';
 import { InjectKysely } from 'nestjs-kysely';
 import { SpaceMemberService } from './space-member.service';
 import { SpaceRole } from '../../../common/helpers/types/permission';
+import { QueueJob, QueueName } from 'src/integrations/queue/constants';
+import { Queue } from 'bullmq';
+import { InjectQueue } from '@nestjs/bullmq';
 
 @Injectable()
 export class SpaceService {
@@ -21,6 +24,7 @@ export class SpaceService {
     private spaceRepo: SpaceRepo,
     private spaceMemberService: SpaceMemberService,
     @InjectKysely() private readonly db: KyselyDB,
+    @InjectQueue(QueueName.ATTACHEMENT_QUEUE) private attachmentQueue: Queue,
   ) {}
 
   async createSpace(
@@ -88,10 +92,24 @@ export class SpaceService {
     updateSpaceDto: UpdateSpaceDto,
     workspaceId: string,
   ): Promise<Space> {
+    if (updateSpaceDto?.slug) {
+      const slugExists = await this.spaceRepo.slugExists(
+        updateSpaceDto.slug,
+        workspaceId,
+      );
+
+      if (slugExists) {
+        throw new BadRequestException(
+          'Space slug exists. Please use a unique space slug',
+        );
+      }
+    }
+
     return await this.spaceRepo.updateSpace(
       {
         name: updateSpaceDto.name,
         description: updateSpaceDto.description,
+        slug: updateSpaceDto.slug,
       },
       updateSpaceDto.spaceId,
       workspaceId,
@@ -120,4 +138,14 @@ export class SpaceService {
 
     return spaces;
   }
+
+  async deleteSpace(spaceId: string, workspaceId: string): Promise<void> {
+    const space = await this.spaceRepo.findById(spaceId, workspaceId);
+    if (!space) {
+      throw new NotFoundException('Space not found');
+    }
+
+    await this.spaceRepo.deleteSpace(spaceId, workspaceId);
+    await this.attachmentQueue.add(QueueJob.DELETE_SPACE_ATTACHMENTS, space);
+  }
 }

apps/server/src/core/space/space.controller.ts

@@ -95,7 +95,7 @@ export class SpaceController {
 
   @HttpCode(HttpStatus.OK)
   @Post('create')
-  createGroup(
+  createSpace(
     @Body() createSpaceDto: CreateSpaceDto,
     @AuthUser() user: User,
     @AuthWorkspace() workspace: Workspace,
@@ -111,7 +111,7 @@ export class SpaceController {
 
   @HttpCode(HttpStatus.OK)
   @Post('update')
-  async updateGroup(
+  async updateSpace(
     @Body() updateSpaceDto: UpdateSpaceDto,
     @AuthUser() user: User,
     @AuthWorkspace() workspace: Workspace,
@@ -126,6 +126,23 @@ export class SpaceController {
     return this.spaceService.updateSpace(updateSpaceDto, workspace.id);
   }
 
+  @HttpCode(HttpStatus.OK)
+  @Post('delete')
+  async deleteSpace(
+    @Body() spaceIdDto: SpaceIdDto,
+    @AuthUser() user: User,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    const ability = await this.spaceAbility.createForUser(
+      user,
+      spaceIdDto.spaceId,
+    );
+    if (ability.cannot(SpaceCaslAction.Manage, SpaceCaslSubject.Settings)) {
+      throw new ForbiddenException();
+    }
+    return this.spaceService.deleteSpace(spaceIdDto.spaceId, workspace.id);
+  }
+
   @HttpCode(HttpStatus.OK)
   @Post('members')
   async getSpaceMembers(

apps/server/src/core/workspace/services/workspace-invitation.service.ts

@@ -248,7 +248,7 @@ export class WorkspaceInvitationService {
       });
 
       await this.mailService.sendToQueue({
-        to: invitation.email,
+        to: invitedByUser.email,
         subject: `${newUser.name} has accepted your Docmost invite`,
         template: emailTemplate,
       });

apps/server/src/database/database.module.ts

@@ -22,6 +22,7 @@ import { AttachmentRepo } from './repos/attachment/attachment.repo';
 import { KyselyDB } from '@docmost/db/types/kysely.types';
 import * as process from 'node:process';
 import { MigrationService } from '@docmost/db/services/migration.service';
+import { UserTokenRepo } from './repos/user-token/user-token.repo';
 
 // https://github.com/brianc/node-postgres/issues/811
 types.setTypeParser(types.builtins.INT8, (val) => Number(val));
@@ -66,6 +67,7 @@ types.setTypeParser(types.builtins.INT8, (val) => Number(val));
     PageHistoryRepo,
     CommentRepo,
     AttachmentRepo,
+    UserTokenRepo,
   ],
   exports: [
     WorkspaceRepo,
@@ -78,6 +80,7 @@ types.setTypeParser(types.builtins.INT8, (val) => Number(val));
     PageHistoryRepo,
     CommentRepo,
     AttachmentRepo,
+    UserTokenRepo,
   ],
 })
 export class DatabaseModule implements OnModuleDestroy, OnApplicationBootstrap {

apps/server/src/database/migrations/20240903T124647-user-tokens.ts

@@ -0,0 +1,27 @@
+import { sql, Kysely } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('user_tokens')
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('token', 'varchar', (col) => col.notNull())
+    .addColumn('type', 'varchar', (col) => col.notNull())
+    .addColumn('user_id', 'uuid', (col) =>
+      col.notNull().references('users.id').onDelete('cascade'),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade'),
+    )
+    .addColumn('expires_at', 'timestamptz')
+    .addColumn('used_at', 'timestamptz', (col) => col)
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable('user_tokens').execute();
+}

apps/server/src/database/repos/attachment/attachment.repo.ts

@@ -40,6 +40,21 @@ export class AttachmentRepo {
       .executeTakeFirst();
   }
 
+  async findBySpaceId(
+    spaceId: string,
+    opts?: {
+      trx?: KyselyTransaction;
+    },
+  ): Promise<Attachment[]> {
+    const db = dbOrTx(this.db, opts?.trx);
+
+    return db
+      .selectFrom('attachments')
+      .selectAll()
+      .where('spaceId', '=', spaceId)
+      .execute();
+  }
+
   async updateAttachment(
     updatableAttachment: UpdatableAttachment,
     attachmentId: string,
@@ -52,7 +67,7 @@ export class AttachmentRepo {
       .executeTakeFirst();
   }
 
-  async deleteAttachment(attachmentId: string): Promise<void> {
+  async deleteAttachmentById(attachmentId: string): Promise<void> {
     await this.db
       .deleteFrom('attachments')
       .where('id', '=', attachmentId)

apps/server/src/database/repos/space/space-member.repo.ts

@@ -64,7 +64,7 @@ export class SpaceMemberRepo {
     } else if (opts.groupId) {
       query = query.where('groupId', '=', opts.groupId);
     } else {
-      throw new BadRequestException('Please provider a userId or groupId');
+      throw new BadRequestException('Please provide a userId or groupId');
     }
     return query.executeTakeFirst();
   }

apps/server/src/database/repos/user-token/user-token.repo.ts

@@ -0,0 +1,102 @@
+import {
+  InsertableUserToken,
+  UpdatableUserToken,
+  UserToken,
+} from '@docmost/db/types/entity.types';
+import { KyselyDB, KyselyTransaction } from '@docmost/db/types/kysely.types';
+import { dbOrTx } from '@docmost/db/utils';
+import { Injectable } from '@nestjs/common';
+import { InjectKysely } from 'nestjs-kysely';
+
+@Injectable()
+export class UserTokenRepo {
+  constructor(@InjectKysely() private readonly db: KyselyDB) {}
+
+  async findById(
+    token: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<UserToken> {
+    const db = dbOrTx(this.db, trx);
+
+    return db
+      .selectFrom('userTokens')
+      .select([
+        'id',
+        'token',
+        'userId',
+        'workspaceId',
+        'type',
+        'expiresAt',
+        'usedAt',
+        'createdAt',
+      ])
+      .where('token', '=', token)
+      .where('workspaceId', '=', workspaceId)
+      .executeTakeFirst();
+  }
+
+  async insertUserToken(
+    insertableUserToken: InsertableUserToken,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .insertInto('userTokens')
+      .values(insertableUserToken)
+      .returningAll()
+      .executeTakeFirst();
+  }
+
+  async findByUserId(
+    userId: string,
+    workspaceId: string,
+    tokenType: string,
+    trx?: KyselyTransaction,
+  ): Promise<UserToken[]> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .selectFrom('userTokens')
+      .select([
+        'id',
+        'token',
+        'userId',
+        'workspaceId',
+        'type',
+        'expiresAt',
+        'usedAt',
+        'createdAt',
+      ])
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('type', '=', tokenType)
+      .orderBy('expiresAt desc')
+      .execute();
+  }
+
+  async updateUserToken(
+    updatableUserToken: UpdatableUserToken,
+    userTokenId: string,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .updateTable('userTokens')
+      .set(updatableUserToken)
+      .where('id', '=', userTokenId)
+      .execute();
+  }
+
+  async deleteToken(token: string, trx?: KyselyTransaction): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db.deleteFrom('userTokens').where('token', '=', token).execute();
+  }
+
+  async deleteExpiredUserTokens(trx?: KyselyTransaction): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db
+      .deleteFrom('userTokens')
+      .where('expiresAt', '<', new Date())
+      .execute();
+  }
+}

apps/server/src/database/repos/user/user.repo.ts

@@ -102,7 +102,7 @@ export class UserRepo {
       name: insertableUser.name || insertableUser.email.toLowerCase(),
       email: insertableUser.email.toLowerCase(),
       password: await hashPassword(insertableUser.password),
-      locale: 'en',
+      locale: 'en-US',
       role: insertableUser?.role,
       lastLoginAt: new Date(),
     };

apps/server/src/database/types/db.d.ts

@@ -1,3 +1,8 @@
+/**
+ * This file was generated by kysely-codegen.
+ * Please do not edit it manually.
+ */
+
 import type { ColumnType } from "kysely";
 
 export type Generated<T> = T extends ColumnType<infer S, infer I, infer U>
@@ -11,7 +16,7 @@ export type Json = JsonValue;
 export type JsonArray = JsonValue[];
 
 export type JsonObject = {
-  [K in string]?: JsonValue;
+  [x: string]: JsonValue | undefined;
 };
 
 export type JsonPrimitive = boolean | number | string | null;
@@ -157,6 +162,17 @@ export interface Users {
   workspaceId: string | null;
 }
 
+export interface UserTokens {
+  createdAt: Generated<Timestamp>;
+  expiresAt: Timestamp | null;
+  id: Generated<string>;
+  token: string;
+  type: string;
+  usedAt: Timestamp | null;
+  userId: string;
+  workspaceId: string | null;
+}
+
 export interface WorkspaceInvitations {
   createdAt: Generated<Timestamp>;
   email: string | null;
@@ -195,6 +211,7 @@ export interface DB {
   spaceMembers: SpaceMembers;
   spaces: Spaces;
   users: Users;
+  userTokens: UserTokens;
   workspaceInvitations: WorkspaceInvitations;
   workspaces: Workspaces;
 }

apps/server/src/database/types/entity.types.ts

@@ -11,6 +11,7 @@ import {
   GroupUsers,
   SpaceMembers,
   WorkspaceInvitations,
+  UserTokens,
 } from './db';
 
 // Workspace
@@ -71,3 +72,8 @@ export type UpdatableComment = Updateable<Omit<Comments, 'id'>>;
 export type Attachment = Selectable<Attachments>;
 export type InsertableAttachment = Insertable<Attachments>;
 export type UpdatableAttachment = Updateable<Omit<Attachments, 'id'>>;
+
+// User Token
+export type UserToken = Selectable<UserTokens>;
+export type InsertableUserToken = Insertable<UserTokens>;
+export type UpdatableUserToken = Updateable<Omit<UserTokens, 'id'>>;

apps/server/src/integrations/environment/environment.service.ts

@@ -62,9 +62,9 @@ export class EnvironmentService {
   getAwsS3Endpoint(): string {
     return this.configService.get<string>('AWS_S3_ENDPOINT');
   }
-  
+
   getAwsS3ForcePathStyle(): boolean {
-    return this.configService.get<boolean>('AWS_S3_FORCE_PATH_STYLE')
+    return this.configService.get<boolean>('AWS_S3_FORCE_PATH_STYLE');
   }
 
   getAwsS3Url(): string {
@@ -98,6 +98,13 @@ export class EnvironmentService {
     return secure === 'true';
   }
 
+  getSmtpIgnoreTLS(): boolean {
+    const ignoretls = this.configService
+      .get<string>('SMTP_IGNORETLS', 'false')
+      .toLowerCase();
+    return ignoretls === 'true';
+  }
+
   getSmtpUsername(): string {
     return this.configService.get<string>('SMTP_USERNAME');
   }
@@ -110,37 +117,6 @@ export class EnvironmentService {
     return this.configService.get<string>('POSTMARK_TOKEN');
   }
 
-  getLdapBaseDn(): string {
-    return this.configService.get<string>('LDAP_BASEDN')
-  }
-
-  getLdapDomainSuffix(): string {
-    return this.configService.get<string>('LDAP_DOMAINSUFFIX');
-  }
-
-  getLdapUsername(): string {
-    return this.configService.get<string>('LDAP_USERNAME')
-  }
-
-  getLdapPassword(): string {
-    return this.configService.get<string>('LDAP_PASSWORD')
-  }
-
-  getLdapNameAttribute(): string {
-    return this.configService.get<string>('LDAP_NAMEATTRIBUTE')
-  }
-
-  getLdapMailAttribute(): string {
-    return this.configService.get<string>('LDAP_MAILATTRIBUTE')
-  }
-
-  usingNtlmAuth(): boolean {
-    const ntlmAuth = this.configService
-      .get<string>('VITE_NTLM_AUTH', 'false')
-      .toLowerCase();
-    return ntlmAuth === 'true';
-  }
-
   isCloud(): boolean {
     const cloudConfig = this.configService
       .get<string>('CLOUD', 'false')

apps/server/src/integrations/export/export.controller.ts

@@ -61,7 +61,8 @@ export class ImportController {
 
     res.headers({
       'Content-Type': getMimeType(fileExt),
-      'Content-Disposition': 'attachment; filename="' + fileName + '"',
+      'Content-Disposition':
+        'attachment; filename="' + encodeURIComponent(fileName) + '"',
     });
 
     res.send(rawContent);

apps/server/src/integrations/export/turndown-utils.ts

@@ -22,6 +22,7 @@ export function turndown(html: string): string {
     listParagraph,
     mathInline,
     mathBlock,
+    iframeEmbed,
   ]);
   return turndownService.turndown(html).replaceAll('<br>', ' ');
 }
@@ -120,3 +121,15 @@ function mathBlock(turndownService: TurndownService) {
     },
   });
 }
+
+function iframeEmbed(turndownService: TurndownService) {
+  turndownService.addRule('iframeEmbed', {
+    filter: function (node: HTMLInputElement) {
+      return node.nodeName === 'IFRAME';
+    },
+    replacement: function (content: any, node: HTMLInputElement) {
+      const src = node.getAttribute('src');
+      return '[' + src + '](' + src + ')';
+    },
+  });
+}

apps/server/src/integrations/health/redis.health.ts

@@ -22,6 +22,7 @@ export class RedisHealthIndicator extends HealthIndicator {
       });
 
       await redis.ping();
+      redis.disconnect();
       return this.getStatus(key, true);
     } catch (e) {
       this.logger.error(e);

apps/server/src/integrations/import/import.module.ts

@@ -4,6 +4,6 @@ import { ImportController } from './import.controller';
 
 @Module({
   providers: [ImportService],
-  controllers: [ImportController]
+  controllers: [ImportController],
 })
 export class ImportModule {}

apps/server/src/integrations/import/import.service.ts

@@ -32,8 +32,10 @@ export class ImportService {
   ): Promise<void> {
     const file = await filePromise;
     const fileBuffer = await file.toBuffer();
-    const fileName = sanitize(file.filename).slice(0, 255).split('.')[0];
     const fileExtension = path.extname(file.filename).toLowerCase();
+    const fileName = sanitize(
+      path.basename(file.filename, fileExtension).slice(0, 255),
+    );
     const fileContent = fileBuffer.toString();
 
     let prosemirrorState = null;

apps/server/src/integrations/import/utils/callout.marked.ts

@@ -0,0 +1,41 @@
+import { Token, marked } from 'marked';
+
+interface CalloutToken {
+  type: 'callout';
+  calloutType: string;
+  text: string;
+  raw: string;
+}
+
+export const calloutExtension = {
+  name: 'callout',
+  level: 'block',
+  start(src: string) {
+    return src.match(/:::/)?.index ?? -1;
+  },
+  tokenizer(src: string): CalloutToken | undefined {
+    const rule = /^:::([a-zA-Z0-9]+)\s+([\s\S]+?):::/;
+    const match = rule.exec(src);
+
+    const validCalloutTypes = ['info', 'success', 'warning', 'danger'];
+
+    if (match) {
+      let type = match[1];
+      if (!validCalloutTypes.includes(type)) {
+        type = 'info';
+      }
+      return {
+        type: 'callout',
+        calloutType: type,
+        raw: match[0],
+        text: match[2].trim(),
+      };
+    }
+  },
+  renderer(token: Token) {
+    const calloutToken = token as CalloutToken;
+    const body = marked.parse(calloutToken.text);
+
+    return `<div data-type="callout" data-callout-type="${calloutToken.calloutType}">${body}</div>`;
+  },
+};

apps/server/src/integrations/import/utils/marked.utils.ts

@@ -1,4 +1,5 @@
 import { marked } from 'marked';
+import { calloutExtension } from './callout.marked';
 
 marked.use({
   renderer: {
@@ -25,6 +26,8 @@ marked.use({
   },
 });
 
+marked.use({ extensions: [calloutExtension] });
+
 export async function markdownToHtml(markdownInput: string): Promise<string> {
   const YAML_FONT_MATTER_REGEX = /^\s*---[\s\S]*?---\s*/;
 

apps/server/src/integrations/mail/providers/mail.provider.ts

@@ -27,11 +27,14 @@ export const mailDriverConfigProvider = {
     switch (driver) {
       case MailOption.SMTP:
         let auth = undefined;
-        if (environmentService.getSmtpUsername() && environmentService.getSmtpPassword()) {
+        if (
+          environmentService.getSmtpUsername() &&
+          environmentService.getSmtpPassword()
+        ) {
           auth = {
-              user: environmentService.getSmtpUsername(),
+            user: environmentService.getSmtpUsername(),
-              pass: environmentService.getSmtpPassword(),
+            pass: environmentService.getSmtpPassword(),
-            };
+          };
         }
         return {
           driver,
@@ -41,6 +44,7 @@ export const mailDriverConfigProvider = {
             connectionTimeout: 30 * 1000, // 30 seconds
             auth,
             secure: environmentService.getSmtpSecure(),
+            ignoreTLS: environmentService.getSmtpIgnoreTLS()
           } as SMTPTransport.Options,
         };
 

apps/server/src/integrations/ntlm/ntlm.controller.ts

@@ -1,86 +0,0 @@
-import {
-  Controller,
-  Get,
-  Req,
-  Res,
-  HttpException,
-  HttpStatus,
-  Post,
-} from '@nestjs/common';
-
-import { FastifyRequest, FastifyReply } from 'fastify';
-
-import {
-  NTLMNegotiationMessage,
-  NTLMChallengeMessage,
-  NTLMAuthenticateMessage,
-  MessageType,
-} from 'ntlm-server';
-
-import { EnvironmentService } from '../environment/environment.service';
-import { NTLMService } from './ntlm.service';
-
-@Controller()
-export class NTLMController {
-  constructor(
-    private readonly ntlmService: NTLMService,
-    private readonly environmentService: EnvironmentService,
-  ) {}
-
-  @Post('auth/ntlm')
-  async ntlmAuth(@Req() req, @Res() res: FastifyReply) {
-    const authHeader = req.headers['authorization'];
-
-    if (!authHeader) {
-      // Step 1: Challenge the client for NTLM authentication
-      return res.status(401).header('WWW-Authenticate', 'NTLM').send();
-    }
-
-    if (authHeader.startsWith('NTLM ')) {
-      // Step 2: Handle NTLM negotiation message
-      const clientNegotiation = new NTLMNegotiationMessage(authHeader);
-
-      if (clientNegotiation.messageType === MessageType.NEGOTIATE) {
-        // Step 3: Send NTLM challenge message
-        const serverChallenge = new NTLMChallengeMessage(clientNegotiation);
-        const base64Challenge = serverChallenge.toBuffer().toString('base64');
-
-        return res
-          .status(401)
-          .header('WWW-Authenticate', `NTLM ${base64Challenge}`)
-          .send();
-      } else if (clientNegotiation.messageType === MessageType.AUTHENTICATE) {
-        // Step 4: Handle NTLM Authenticate message
-        const clientAuthentication = new NTLMAuthenticateMessage(authHeader);
-
-        // Here you'd perform LDAP or Active Directory authentication
-
-        const client = this.ntlmService.createClient(
-          clientAuthentication.domainName,
-        );
-
-        // Asynchronous bind to AD
-        await this.ntlmService.bindAsync(client);
-
-        const results = await this.ntlmService.searchAsync(client, {
-          scope: 'sub',
-          filter: `(userPrincipalName=${clientAuthentication.userName}@${clientAuthentication.domainName}*)`,
-        });
-
-        if (results.length == 1) {
-          const ntlmSignInResult = await this.ntlmService.login(
-            results.at(0)[this.environmentService.getLdapNameAttribute()],
-            results.at(0)[this.environmentService.getLdapMailAttribute()],
-            req.raw.workspaceId,
-          );
-          return res.status(200).send(ntlmSignInResult);
-        } else return res.status(403).send();
-      } else {
-        console.warn('Invalid NTLM Message received.');
-        return res.status(400).send('Invalid NTLM Message');
-      }
-    }
-
-    res.status(400).send('Bad NTLM request');
-  }
-}

apps/server/src/integrations/ntlm/ntlm.module.ts

@@ -1,13 +0,0 @@
-import { Module } from '@nestjs/common';
-import { NTLMController } from './ntlm.controller';
-import { NTLMService } from './ntlm.service';
-import { TokenModule } from 'src/core/auth/token.module';
-import { WorkspaceModule } from 'src/core/workspace/workspace.module';
-import { AuthModule } from 'src/core/auth/auth.module';
-
-@Module({
-  imports: [TokenModule, WorkspaceModule, AuthModule],
-  controllers: [NTLMController],
-  providers: [NTLMService],
-})
-export class NTLMModule {}

apps/server/src/integrations/ntlm/ntlm.service.ts

@@ -1,110 +0,0 @@
-import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';
-import { EnvironmentService } from '../environment/environment.service';
-import * as ldap from 'ldapjs';
-import { UserRepo } from '@docmost/db/repos/user/user.repo';
-import { TokensDto } from 'src/core/auth/dto/tokens.dto';
-import { TokenService } from 'src/core/auth/services/token.service';
-import { AuthService } from 'src/core/auth/services/auth.service';
-
-@Injectable()
-export class NTLMService {
-  constructor(
-    private readonly environmentService: EnvironmentService,
-    private authService: AuthService,
-    private tokenService: TokenService,
-    private userRepo: UserRepo,
-  ) {}
-
-  createClient = (domain: string) =>
-    ldap.createClient({
-      url: 'ldap://' + domain + this.environmentService.getLdapDomainSuffix(),
-    });
-
-  // Promisified version of ldap.Client.bind
-  bindAsync = (client: ldap.Client): Promise<void> => {
-    return new Promise((resolve, reject) => {
-      client.bind(
-        this.environmentService.getLdapUsername(),
-        this.environmentService.getLdapPassword(),
-        (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        },
-      );
-    });
-  };
-
-  // Promisified version of client.search
-  searchAsync = (
-    client: ldap.Client,
-    options: ldap.SearchOptions,
-  ): Promise<any[]> => {
-    const baseDN: string = this.environmentService.getLdapBaseDn();
-    return new Promise((resolve, reject) => {
-      const entries: any[] = [];
-
-      client.search(baseDN, options, (err, res) => {
-        if (err) {
-          reject(err);
-        }
-
-        res.on('searchEntry', (entry) => {
-          const attributes = Object.fromEntries(
-            entry.attributes.map(({ type, values }) => [
-              type,
-              values.length > 1 ? values : values[0],
-            ]),
-          );
-          entries.push(attributes);
-        });
-
-        res.on('end', () => {
-          resolve(entries);
-        });
-
-        res.on('error', (error) => {
-          reject(error);
-        });
-      });
-    });
-  };
-
-  async login(name: string, email: string, workspaceId: string) {
-    const user = await this.userRepo.findByEmail(email, workspaceId, false);
-
-    if (!user) {
-      const tokensR = await this.authService.register(
-        {
-          name,
-          email,
-          password: this.generateRandomPassword(12),
-        },
-        workspaceId,
-      );
-
-      return tokensR;
-    }
-
-    user.lastLoginAt = new Date();
-    await this.userRepo.updateLastLogin(user.id, workspaceId);
-
-    const tokens: TokensDto = await this.tokenService.generateTokens(user);
-    return { tokens };
-  }
-
-  generateRandomPassword(length: number): string {
-    const characters =
-      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+[]{}|;:,.<>?';
-    let password = '';
-
-    for (let i = 0; i < length; i++) {
-      const randomIndex = Math.floor(Math.random() * characters.length);
-      password += characters[randomIndex];
-    }
-
-    return password;
-  }
-}

apps/server/src/integrations/queue/constants/queue.constants.ts

@@ -1,7 +1,10 @@
 export enum QueueName {
   EMAIL_QUEUE = '{email-queue}',
+  ATTACHEMENT_QUEUE = '{attachment-queue}',
 }
 
 export enum QueueJob {
   SEND_EMAIL = 'send-email',
+  DELETE_SPACE_ATTACHMENTS = 'delete-space-attachments',
+  DELETE_PAGE_ATTACHMENTS = 'delete-page-attachments',
 }

apps/server/src/integrations/queue/queue.module.ts

@@ -31,6 +31,9 @@ import { QueueName } from './constants';
     BullModule.registerQueue({
       name: QueueName.EMAIL_QUEUE,
     }),
+    BullModule.registerQueue({
+      name: QueueName.ATTACHEMENT_QUEUE,
+    }),
   ],
   exports: [BullModule],
 })

apps/server/src/integrations/transactional/emails/forgot-password-email.tsx

@@ -0,0 +1,28 @@
+import { Button, Link, Section, Text } from '@react-email/components';
+import * as React from 'react';
+import { button, content, paragraph } from '../css/styles';
+import { MailBody } from '../partials/partials';
+
+interface Props {
+  username: string;
+  resetLink: string;
+}
+
+export const ForgotPasswordEmail = ({ username, resetLink }: Props) => {
+  return (
+    <MailBody>
+      <Section style={content}>
+        <Text style={paragraph}>Hi {username},</Text>
+        <Text style={paragraph}>
+          We received a request from you to reset your password.
+        </Text>
+          <Link href={resetLink}> Click here to set a new password</Link>
+        <Text style={paragraph}>
+          If you did not request a password reset, please ignore this email.
+        </Text>
+      </Section>
+    </MailBody>
+  );
+};
+
+export default ForgotPasswordEmail;

apps/server/src/integrations/transactional/utils/utils.ts

@@ -1,6 +1,6 @@
 export const formatDate = (date: Date) => {
-  new Intl.DateTimeFormat("en", {
+  new Intl.DateTimeFormat('en', {
-    dateStyle: "medium",
+    dateStyle: 'medium',
-    timeStyle: "medium",
+    timeStyle: 'medium',
   }).format(date);
 };

package.json

@@ -1,7 +1,7 @@
 {
   "name": "docmost",
   "homepage": "https://docmost.com",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": true,
   "scripts": {
     "build": "nx run-many -t build",

packages/editor-ext/src/lib/attachment/attachment.ts

@@ -6,10 +6,11 @@ export interface AttachmentOptions {
   HTMLAttributes: Record<string, any>;
   view: any;
 }
+
 export interface AttachmentAttributes {
   url?: string;
   name?: string;
-  mime?: string; // mime type e.g. application/zip
+  mime?: string; // e.g. application/zip
   size?: number;
   attachmentId?: string;
 }
@@ -93,6 +94,15 @@ export const Attachment = Node.create<AttachmentOptions>({
         this.options.HTMLAttributes,
         HTMLAttributes,
       ),
+      [
+        "a",
+        {
+          href: HTMLAttributes["data-attachment-url"],
+          class: "attachment",
+          target: "blank",
+        },
+        `${HTMLAttributes["data-attachment-name"]}`,
+      ],
     ];
   },