initial v0.3.3 commit

.github/workflows/regular-tests.yaml

@@ -21,7 +21,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
-            go-version: '1.22.5'
+            go-version: '1.23.3'
       - uses: golangci/golangci-lint-action@v5
         with:
           version: v1.60
@@ -41,4 +41,11 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
       - working-directory: frontend
-        run: npm i eslint && npm run lint
+        run: npm i && npm run lint
+  test-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+      - working-directory: frontend
+        run: npm i && npm run test

.github/workflows/release.yaml

@@ -61,7 +61,7 @@ jobs:
           JSON="${{ steps.meta.outputs.tags }}"
           # Use jq to remove 'v' from the version field
           JSON=$(echo "$JSON" | sed 's/filebrowser:v/filebrowser:/')
-          echo "cleaned_tag=$JSON" >> $GITHUB_OUTPUT
+          echo "CLEANED_TAG=$JSON" >> $GITHUB_OUTPUT
       - name: Build and push
         uses: docker/build-push-action@v6
         with:
@@ -72,5 +72,5 @@ jobs:
           platforms: linux/amd64,linux/arm64,linux/arm/v7
           file: ./Dockerfile
           push: true
-          tags: ${{ steps.modify-json.outputs.cleaned_tag }}
+          tags: ${{ steps.modify-json.outputs.CLEANED_TAG }}
           labels: ${{ steps.meta.outputs.labels }}

.github/workflows/release_dev.yaml

@@ -10,7 +10,7 @@ permissions:
 
 jobs:
   push_release_to_registry:
-    name: Push dev release
+    name: Push release
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -35,16 +35,16 @@ jobs:
           JSON="${{ steps.meta.outputs.tags }}"
           # Use jq to remove 'v' from the version field
           JSON=$(echo "$JSON" | sed 's/filebrowser:v/filebrowser:/')
-          echo "CLEANED_TAG=$JSON" >> $GITHUB_ENV
+          echo "cleaned_tag=$JSON" >> $GITHUB_OUTPUT
       - name: Build and push
         uses: docker/build-push-action@v6
         with:
+          context: .
           build-args: |
             VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
             REVISION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
-          context: .
           platforms: linux/amd64
           file: ./Dockerfile
           push: true
-          tags: ${{ env.CLEANED_TAG }}
+          tags: ${{ steps.modify-json.outputs.cleaned_tag }}
           labels: ${{ steps.meta.outputs.labels }}

CHANGELOG.md

@@ -2,6 +2,58 @@
 
 All notable changes to this project will be documented in this file. For commit guidelines, please refer to [Standard Version](https://github.com/conventional-changelog/standard-version).
 
+## v0.3.3
+
+  **New Features**
+  - Navigating remembers your previous scroll position when opening items and then navigating backwards.
+  - New Icons with larger selection of file types
+  - file "type" is shown on item info page.
+  - added optional non-root "filebrowser" user for docker image. See https://github.com/gtsteffaniak/filebrowser/issues/251
+  - File preview supports more file types:
+    - images: jpg, bmp, gif, tiff, png, svg, heic, webp
+
+  **Notes**:
+  - The file "type" is now either "directory" or a specific mimetype such as "text/xml".
+  - update safari styling
+
+  **Bugfixes**:
+  - Delete/move file/folders sometimes wouldn't work.
+  - Possible fix for context menu not showing issue. See https://github.com/gtsteffaniak/filebrowser/issues/251
+  - Fixed drag/drop not refreshing immediately to reflect changes.
+
+## v0.3.2
+
+  **New Features**
+  - Mobile search has the same features as desktop.
+
+  **Notes**:
+  - Added compression. Helpful for browsing folders with a large number of items. Considering https://github.com/gtsteffaniak/filebrowser/issues/201 resolved, although future pagination support will still come.
+  - Compressed download options limited to `.zip` and `.tar.gz`
+  - right-click context menu stays in view.
+
+  **Bugfixes**:
+  - search result links when non-default baseUrl configured
+  - frontend sort bug squashed https://github.com/gtsteffaniak/filebrowser/issues/230
+  - bug which caused "noauth" method not to work after v0.3.0 routes update
+
+## v0.3.1
+
+  **New Features**
+  - Adds Smart Indexing by default.
+
+  **Notes**:
+  - Optimized api request response times via improved caching and simplified actions.
+  - User information persists more reliably.
+  - Added [indexing doc](./docs/indexing.md) to explain the expectations around indexing and how it works.
+  - The index should also use less RAM than it did in v0.3.0.
+
+  **Bugfixes**:
+  - Tweaked sorting by name, fixes case sensitive and numeric sorting. https://github.com/gtsteffaniak/filebrowser/issues/230
+  - Fixed unnecessary authentication status checks each route change
+  - Fix create file action issue.
+  - some small javascript related issues.
+  - Fixes pretty big bug viewing raw content in v0.3.0 (utf format message)
+
 ## v0.3.0
 
   This Release focuses on the API and making it more accessible for developers to access functions without the UI.
@@ -153,7 +205,7 @@ This change focuses on minimizing and simplifying build process.
 - The shell feature has been deprecated.
   - Custom commands can be executed within the Docker container if needed.
 - The JSON config file is no longer used.
-  - All configurations are now performed via the advanced `filebrowser.yaml`.
+  - All configurations are now performed via the advanced `config.yaml`.
   - The only allowed flag is specifying the config file.
 - Removed old code for migrating database versions.
 - Eliminated all unused `cmd` code.

Dockerfile

@@ -20,8 +20,12 @@ RUN npm run build-docker
 FROM alpine:latest
 ENV FILEBROWSER_NO_EMBEDED="true"
 RUN apk --no-cache add ca-certificates mailcap
-COPY --from=base /app/filebrowser* ./
+WORKDIR /home/filebrowser
+RUN adduser -D -s /bin/true -u 1000 filebrowser
+USER filebrowser
+COPY --from=base --chown=filebrowser:1000 /app/filebrowser* ./
+COPY --from=nbuild --chown=filebrowser:1000 /app/dist/ ./http/dist/
+USER root
 # exposing default port for auto discovery.
 EXPOSE 80
-COPY --from=nbuild /app/dist/ ./http/dist/
 ENTRYPOINT [ "./filebrowser" ]

Dockerfile.playwright

@@ -8,7 +8,7 @@ WORKDIR /app
 COPY ./frontend/package.json ./
 RUN npm i --maxsockets 1
 RUN npx playwright install --with-deps firefox
-COPY [ "backend/filebrowser.yaml", "./" ]
+COPY [ "backend/config.yaml", "./" ]
 COPY  ./frontend/ ./frontend
 WORKDIR /app/frontend
 RUN npm run build-docker

README.md

@@ -9,30 +9,42 @@
   <img width="800" src="https://github.com/user-attachments/assets/e4a47229-66f8-4838-9575-dd2413596688" title="Main Screenshot">
 </p>
 
+> [!Note]
+> Starting with v0.3.3, configuration file mapping is different to support non-root user. Now, the default config file name is `config.yaml` and in docker the path is `/home/filebrowser/config.yaml` and `/home/filebrowser/<database_file>`. Please read the usage below to properly update your config to point the new config location.
+
 > [!WARNING]
-> Starting with `v0.3.0` API routes have been slightly altered for friendly usage outside of the UI.
-> If on windows, please use docker. The windows binary is unstable and may not work.
+> - There is no stable version yet. Always check release notes for bug fixes on functionality that may have been changed. If you notice any unexpected behavior -- please open an issue to have it fixed soon.
+> - If on windows, please use docker. The windows binary is unstable and may not work.
 
 FileBrowser Quantum is a fork of the file browser opensource project with the following changes:
 
-  1. [x] Efficiently indexed files
+  1. [x] Indexes files efficiently. See [indexing readme](./docs/indexing.md)
      - Real-time search results as you type
-     - Search Works with more type filters
-     - Enhanced interactive results page.
-     - file/folder sizes are shown in the response
-  1. [x] Revamped and simplified GUI navbar and sidebar menu.
+     - Search supports file/folder sizes and many file type filters.
+     - Enhanced interactive results that show file/folder sizes.
+  2. [x] Revamped and simplified GUI navbar and sidebar menu.
      - Additional compact view mode as well as refreshed view mode
        styles.
-  1. [x] Revamped and simplified configuration via `filebrowser.yml` config file.
-  1. [x] Better listing browsing
+     - Many graphical and user experience improvements.
+     - right-click context menu
+  3. [x] Revamped and simplified configuration via `filebrowser.yml` config file.
+  4. [x] Better listing browsing
      - Switching view modes is instant
      - Folder sizes are shown as well
      - Changing Sort order is instant
      - The entire directory is loaded in 1/3 the time
-  1. Developer API support
+  5. [x] Developer API support
      - Can create long-live API Tokens.
      - Helpful Swagger page available at `/swagger` endpoint.
 
+Notable features that this fork *does not* have (removed):
+
+ - jobs/runners are not supported yet (planned).
+ - shell commands are completely removed and will not be returned.
+ - themes and branding are not fully supported yet (planned).
+ - see feature matrix below for more.
+ - pagination for directory items, so large directories with more than 100,000 items may be slow to load or not load at all.
+
 ## About
 
 FileBrowser Quantum provides a file-managing interface within a specified directory
@@ -82,7 +94,13 @@ Using docker:
 1. docker run (no persistent db):
 
 ```
-docker run -it -v /path/to/folder:/srv -p 80:80 gtstef/filebrowser
+docker run -it -v /path/to/folder:/srv -v $(pwd)/config.yaml:/home/filebrowser/config.yaml -p 80:80 gtstef/filebrowser
+```
+
+or optionally, as non-root filebrowser user:
+
+```
+docker run -u filebrowser -it -v $(pwd)/config.yaml:/home/filebrowser/config.yaml -v /path/to/folder:/srv -p 80:80 gtstef/filebrowser
 ```
 
 1. docker compose:
@@ -94,11 +112,14 @@ services:
   filebrowser:
     volumes:
       - '/path/to/folder:/srv' # required (for now not configurable)
-      - './database:/database'  # optional if you want db to persist - configure a path under "database" dir in config file.
-      - './filebrowser.yaml:/filebrowser.yaml' # required
+      # optional if you want db to persist - configure a path under "database" dir in config file.
+      - './database:/home/filebrowser/database'
+      - './config.yaml:/home/filebrowser/config.yaml'
     ports:
       - '80:80'
     image: gtstef/filebrowser
+    # optionally run as non-root filebrowser user
+    #user: filebrowser
     restart: always
 ```
 
@@ -109,8 +130,9 @@ services:
   filebrowser:
     volumes:
       - 'storage:/srv' # required (for now not configurable)
-      - './database:/database'  # optional if you want db to persist - configure a path under "database" dir in config file.
-      - './filebrowser.yaml:/filebrowser.yaml' # required
+      # optional if you want db to persist - configure a path under "database" dir in config file.
+      - './database:/home/filebrowser/database'
+      - './config.yaml:/home/filebrowser/config.yaml'
     ports:
       - '80:80'
     image: gtstef/filebrowser
@@ -127,36 +149,41 @@ volumes:
 Not using docker (not recommended), download your binary from releases and run with your custom config file:
 
 ```
-./filebrowser -c <filebrowser.yml or other /path/to/config.yaml>
+./filebrowser -c <config.yaml or other /path/to/config.yaml>
 ```
 
 ## Command Line Usage
 
-There are very few commands available. There are 3 actions done via command line:
+There are very few commands available. There are 3 actions done via the command line:
 
-1. Running the program, as shown on the install step. The only argument used is the config file, if you choose to override default "filebrowser.yaml"
+1. Running the program, as shown in the install step. The only argument used is the config file if you choose to override the default "config.yaml"
 2. Checking the version info via `./filebrowser version`
 3. Updating the DB, which currently only supports adding users via `./filebrowser set -u username,password [-a] [-s "example/scope"]`
 
 ## API Usage
 
-FileBrowser Quantum comes with a swagger page that can be accessed from the API section of settings or by going to `/swagger` to see the full list:
+FileBrowser Quantum allows for the creation of API tokens which can create users, access file information, and update user settings just like what can be done from the UI. You can create API tokens from the settings page via "API Management" section. This section will only show up if the user has "API" permissions, which can be granted by editing the user in user management.
+
+Regardless of whether a user has API permissions, anyone can visit the swagger page which is found at `/swagger`. This swagger page uses a short-live token (2-hour exp) that the UI uses, but allows for quick access to all the API's and their described usage and requirements:
 
 ![image](https://github.com/user-attachments/assets/12abd1f6-21d3-4437-98ed-9b0da6cf2c73)
 
-You use the token as a bearer token. For example in postman:
+When using the API outside of swagger, you will need to set the API token as a bearer token authentication type. This means the authorization header will look like `Authorization: Bearer <token>`. For example in Postman:
 
 Successful Request:
-<img width="500" alt="image" src="https://github.com/user-attachments/assets/4f18fa8a-8d87-4f40-9dc7-3d4407769b59">
+
+<p align="center"><img width="500" alt="image" src="https://github.com/user-attachments/assets/4f18fa8a-8d87-4f40-9dc7-3d4407769b59"></p>
+
 Failed Request
-<img width="500" alt="image" src="https://github.com/user-attachments/assets/4da0deae-f93d-4d94-83b1-68806afb343a">
+
+<p align="center"><img width="500" alt="image" src="https://github.com/user-attachments/assets/4da0deae-f93d-4d94-83b1-68806afb343a"></p>
 
 
 ## Configuration
 
 All configuration is now done via a single configuration file:
-`filebrowser.yaml`, here is an example of minimal [configuration
-file](./backend/filebrowser.yaml).
+`config.yaml`, here is an example of minimal [configuration
+file](./backend/config.yaml).
 
 View the [Configuration Help Page](./docs/configuration.md) for available
 configuration options and other help.
@@ -185,12 +212,12 @@ webdav support                | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
 ftp support                   | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
 Dedicated docs site?          | ❌ | ✅ | ✅ | ✅ | ❌ | ✅ |
 Multiple sources at once      | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
-Docker image size             | 22 MB  | 31 MB  | 240 MB (main image) | 250 MB | ❌ | > 2 GB |
+Docker image size             | 31 MB  | 31 MB  | 240 MB (main image) | 250 MB | ❌ | > 2 GB |
 Min. Memory Requirements      | 128 MB | 128 MB | 128 MB (main image) | 128 MB | ❌ | 4 GB   |
 has standalone binary         | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
 price                         | free | free | free | free tier | free tier | $99+ |
 rich media preview            | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-upload files from the web?    | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
+upload files from the web?    | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 Advanced Search?              | ✅ | ❌ | ❌ | configurable | ✅ | ✅ |
 Indexed Search?               | ✅ | ❌ | ❌ | configurable | ✅ | ✅ |
 Content-aware search?         | ❌ | ❌ | ❌ | configurable | ✅ | ✅ |

backend/auth/auth.go

@@ -3,7 +3,7 @@ package auth
 import (
 	"net/http"
 
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // Auther is the authentication interface.

backend/auth/hook.go

@@ -9,9 +9,9 @@ import (
 	"os/exec"
 	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 type hookCred struct {

backend/auth/json.go

@@ -7,8 +7,8 @@ import (
 	"os"
 	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 type jsonCred struct {

backend/auth/none.go

@@ -3,8 +3,8 @@ package auth
 import (
 	"net/http"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // MethodNoAuth is used to identify no auth.

backend/auth/proxy.go

@@ -4,10 +4,10 @@ import (
 	"net/http"
 	"os"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // MethodProxyAuth is used to identify no auth.

backend/auth/storage.go

@@ -1,7 +1,7 @@
 package auth
 
 import (
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // StorageBackend is a storage backend for auth storage.

backend/cmd/root.go

@@ -7,17 +7,17 @@ import (
 	"os"
 	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/diskcache"
-	"github.com/gtsteffaniak/filebrowser/files"
-	fbhttp "github.com/gtsteffaniak/filebrowser/http"
-	"github.com/gtsteffaniak/filebrowser/img"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/swagger/docs"
+	"github.com/gtsteffaniak/filebrowser/backend/diskcache"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	fbhttp "github.com/gtsteffaniak/filebrowser/backend/http"
+	"github.com/gtsteffaniak/filebrowser/backend/img"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/swagger/docs"
 	"github.com/swaggo/swag"
 
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/version"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/version"
 )
 
 func getStore(config string) (*storage.Storage, bool) {
@@ -47,7 +47,7 @@ func StartFilebrowser() {
 	var help bool
 	// Override the default usage output to use generalUsage()
 	flag.Usage = generalUsage
-	flag.StringVar(&configPath, "c", "filebrowser.yaml", "Path to the config file.")
+	flag.StringVar(&configPath, "c", "config.yaml", "Path to the config file, default: config.yaml")
 	flag.BoolVar(&help, "h", false, "Get help about commands")
 
 	// Parse global flags (before subcommands)
@@ -67,7 +67,7 @@ func StartFilebrowser() {
 	setCmd.StringVar(&user, "u", "", "Comma-separated username and password: \"set -u <username>,<password>\"")
 	setCmd.BoolVar(&asAdmin, "a", false, "Create user as admin user, used in combination with -u")
 	setCmd.StringVar(&scope, "s", "", "Specify a user scope, otherwise default user config scope is used")
-	setCmd.StringVar(&dbConfig, "c", "filebrowser.yaml", "Path to the config file.")
+	setCmd.StringVar(&dbConfig, "c", "config.yaml", "Path to the config file, default: config.yaml")
 
 	// Parse subcommand flags only if a subcommand is specified
 	if len(os.Args) > 1 {
@@ -114,10 +114,6 @@ func StartFilebrowser() {
 		}
 	}
 	store, dbExists := getStore(configPath)
-	indexingInterval := fmt.Sprint(settings.Config.Server.IndexingInterval, " minutes")
-	if !settings.Config.Server.Indexing {
-		indexingInterval = "disabled"
-	}
 	database := fmt.Sprintf("Using existing database  : %v", settings.Config.Server.Database)
 	if !dbExists {
 		database = fmt.Sprintf("Creating new database    : %v", settings.Config.Server.Database)
@@ -127,14 +123,13 @@ func StartFilebrowser() {
 	log.Println("Embeded frontend         :", os.Getenv("FILEBROWSER_NO_EMBEDED") != "true")
 	log.Println(database)
 	log.Println("Sources                  :", settings.Config.Server.Root)
-	log.Println("Indexing interval        :", indexingInterval)
 
 	serverConfig := settings.Config.Server
 	swagInfo := docs.SwaggerInfo
 	swagInfo.BasePath = serverConfig.BaseURL
 	swag.Register(docs.SwaggerInfo.InstanceName(), swagInfo)
 	// initialize indexing and schedule indexing ever n minutes (default 5)
-	go files.InitializeIndex(serverConfig.IndexingInterval, serverConfig.Indexing)
+	go files.InitializeIndex(serverConfig.Indexing)
 	if err := rootCMD(store, &serverConfig); err != nil {
 		log.Fatal("Error starting filebrowser:", err)
 	}

backend/cmd/rule_rm.go

@@ -5,10 +5,10 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/rules.go

@@ -6,10 +6,10 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/rules_add.go

@@ -5,10 +5,10 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/rules_ls.go

@@ -1,7 +1,7 @@
 package cmd
 
 import (
-	"github.com/gtsteffaniak/filebrowser/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
 	"github.com/spf13/cobra"
 )
 

backend/cmd/users.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 var usersCmd = &cobra.Command{

backend/cmd/users_add.go

@@ -3,9 +3,9 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/users_export.go

@@ -1,8 +1,8 @@
 package cmd
 
 import (
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 	"github.com/spf13/cobra"
 )
 

backend/cmd/users_find.go

@@ -3,9 +3,9 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/users_import.go

@@ -8,9 +8,9 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/users_rm.go

@@ -3,8 +3,8 @@ package cmd
 import (
 	"log"
 
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 	"github.com/spf13/cobra"
 )
 

backend/cmd/users_update.go

@@ -3,9 +3,9 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func init() {

backend/cmd/utils.go

@@ -10,8 +10,8 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func mustGetString(flags *pflag.FlagSet, flag string) string {

backend/config.yaml

@@ -1,7 +1,7 @@
 server:
   port: 80
   baseURL:  "/"
-  root: "./srv"
+  root: "/srv"
 auth:
   method: password
   signup: false

backend/files/conditions.go

@@ -14,24 +14,85 @@ var AllFiletypeOptions = []string{
 	"archive",
 	"video",
 	"doc",
-	"dir",
 	"text",
 }
+
+// Document file extensions
 var documentTypes = []string{
-	".word",
-	".pdf",
-	".doc",
-	".docx",
-}
-var textTypes = []string{
-	".text",
-	".sh",
-	".yaml",
-	".yml",
-	".json",
-	".env",
+	// Common Document Formats
+	".doc", ".docx", // Microsoft Word
+	".pdf", // Portable Document Format
+	".odt", // OpenDocument Text
+	".rtf", // Rich Text Format
+	".conf",
+	".bash_history",
+	".gitignore",
+	".htpasswd",
+	".profile",
+	".dockerignore",
+	".editorconfig",
+
+	// Presentation Formats
+	".ppt", ".pptx", // Microsoft PowerPoint
+	".odp", // OpenDocument Presentation
+
+	// google docs
+	".gdoc",
+
+	// google sheet
+	".gsheet",
+
+	// Spreadsheet Formats
+	".xls", ".xlsx", // Microsoft Excel
+	".ods", // OpenDocument Spreadsheet
+
+	// Other Document Formats
+	".epub", // Electronic Publication
+	".mobi", // Amazon Kindle
+	".fb2",  // FictionBook
 }
 
+// Text-based file extensions
+var textTypes = []string{
+	// Common Text Formats
+	".txt",
+	".md", // Markdown
+
+	// Scripting and Programming Languages
+	".sh",        // Bash script
+	".py",        // Python
+	".js",        // JavaScript
+	".ts",        // TypeScript
+	".php",       // PHP
+	".rb",        // Ruby
+	".go",        // Go
+	".java",      // Java
+	".c", ".cpp", // C/C++
+	".cs",    // C#
+	".swift", // Swift
+
+	// Configuration Files
+	".yaml", ".yml", // YAML
+	".json", // JSON
+	".xml",  // XML
+	".ini",  // INI
+	".toml", // TOML
+	".cfg",  // Configuration file
+
+	// Other Text-Based Formats
+	".css",          // Cascading Style Sheets
+	".html", ".htm", // HyperText Markup Language
+	".sql", // SQL
+	".csv", // Comma-Separated Values
+	".tsv", // Tab-Separated Values
+	".log", // Log file
+	".bat", // Batch file
+	".ps1", // PowerShell script
+	".tex", // LaTeX
+	".bib", // BibTeX
+}
+
+// Compressed file extensions
 var compressedFile = []string{
 	".7z",
 	".rar",
@@ -39,6 +100,12 @@ var compressedFile = []string{
 	".tar",
 	".gz",
 	".xz",
+	".bz2",
+	".tgz",  // tar.gz
+	".tbz2", // tar.bz2
+	".lzma",
+	".lz4",
+	".zstd",
 }
 
 type SearchOptions struct {
@@ -48,8 +115,18 @@ type SearchOptions struct {
 	Terms       []string
 }
 
-func ParseSearch(value string) *SearchOptions {
-	opts := &SearchOptions{
+func extendedMimeTypeCheck(extension string) string {
+	if isDoc(extension) {
+		return "application/document"
+	}
+	if isText(extension) {
+		return "text/plain"
+	}
+	return "blob"
+}
+
+func ParseSearch(value string) SearchOptions {
+	opts := SearchOptions{
 		Conditions: map[string]bool{
 			"exact": strings.Contains(value, "case:exact"),
 		},
@@ -145,8 +222,6 @@ func IsMatchingType(extension string, matchType string) bool {
 	switch matchType {
 	case "doc":
 		return isDoc(extension)
-	case "pdf":
-		return extension == ".pdf"
 	case "text":
 		return isText(extension)
 	case "archive":

backend/files/conditions_test.go

@@ -22,7 +22,7 @@ func TestIsMatchingType(t *testing.T) {
 		extension    string
 		expectedType string
 	}{
-		{".pdf", "pdf"},
+		{".pdf", "doc"},
 		{".doc", "doc"},
 		{".docx", "doc"},
 		{".json", "text"},

backend/files/file.go

@@ -11,17 +11,21 @@ import (
 	"io"
 	"mime"
 	"net/http"
+
 	"os"
 	"path/filepath"
+	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
 	"unicode/utf8"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/fileutils"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/fileutils"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 var (
@@ -29,34 +33,30 @@ var (
 	pathMutexesMu sync.Mutex // Mutex to protect the pathMutexes map
 )
 
-type ReducedItem struct {
-	Name    string      `json:"name"`
-	Size    int64       `json:"size"`
-	ModTime time.Time   `json:"modified"`
-	Type    string      `json:"type"`
-	Mode    os.FileMode `json:"-"`
-	Content string      `json:"content,omitempty"`
+type ItemInfo struct {
+	Name    string    `json:"name"`
+	Size    int64     `json:"size"`
+	ModTime time.Time `json:"modified"`
+	Type    string    `json:"type"`
 }
 
 // FileInfo describes a file.
 // reduced item is non-recursive reduced "Items", used to pass flat items array
 type FileInfo struct {
-	Files     []ReducedItem        `json:"-"`
-	Dirs      map[string]*FileInfo `json:"-"`
-	Path      string               `json:"path"`
-	Name      string               `json:"name"`
-	Items     []ReducedItem        `json:"items"`
-	Size      int64                `json:"size"`
-	Extension string               `json:"-"`
-	ModTime   time.Time            `json:"modified"`
-	CacheTime time.Time            `json:"-"`
-	Mode      os.FileMode          `json:"-"`
-	IsSymlink bool                 `json:"isSymlink,omitempty"`
-	Type      string               `json:"type"`
-	Subtitles []string             `json:"subtitles,omitempty"`
-	Content   string               `json:"content,omitempty"`
-	Checksums map[string]string    `json:"checksums,omitempty"`
-	Token     string               `json:"token,omitempty"`
+	ItemInfo
+	Files   []ItemInfo `json:"files"`
+	Folders []ItemInfo `json:"folders"`
+	Path    string     `json:"path"`
+}
+
+// for efficiency, a response will be a pointer to the data
+// extra calculated fields can be added here
+type ExtendedFileInfo struct {
+	*FileInfo
+	Content   string            `json:"content,omitempty"`
+	Subtitles []string          `json:"subtitles,omitempty"`
+	Checksums map[string]string `json:"checksums,omitempty"`
+	Token     string            `json:"token,omitempty"`
 }
 
 // FileOptions are the options when getting a file info.
@@ -66,7 +66,6 @@ type FileOptions struct {
 	Modify     bool
 	Expand     bool
 	ReadHeader bool
-	Token      string
 	Checker    users.Checker
 	Content    bool
 }
@@ -75,206 +74,69 @@ func (f FileOptions) Components() (string, string) {
 	return filepath.Dir(f.Path), filepath.Base(f.Path)
 }
 
-func FileInfoFaster(opts FileOptions) (*FileInfo, error) {
+func FileInfoFaster(opts FileOptions) (ExtendedFileInfo, error) {
 	index := GetIndex(rootPath)
 	opts.Path = index.makeIndexPath(opts.Path)
-
+	response := ExtendedFileInfo{}
 	// Lock access for the specific path
 	pathMutex := getMutex(opts.Path)
 	pathMutex.Lock()
 	defer pathMutex.Unlock()
 	if !opts.Checker.Check(opts.Path) {
-		return nil, os.ErrPermission
+		return response, os.ErrPermission
 	}
+
 	_, isDir, err := GetRealPath(opts.Path)
 	if err != nil {
-		return nil, err
+		return response, err
 	}
 	opts.IsDir = isDir
+	// TODO : whats the best way to save trips to disk here?
+	// disabled using cache because its not clear if this is helping or hurting
 	// check if the file exists in the index
-	info, exists := index.GetReducedMetadata(opts.Path, opts.IsDir)
-	if exists {
-		// Let's not refresh if less than a second has passed
-		if time.Since(info.CacheTime) > time.Second {
-			RefreshFileInfo(opts) //nolint:errcheck
-		}
-		if opts.Content {
-			content := ""
-			content, err = getContent(opts.Path)
-			if err != nil {
-				return info, err
-			}
-			info.Content = content
-		}
-		return info, nil
-	}
-	err = RefreshFileInfo(opts)
+	//info, exists := index.GetReducedMetadata(opts.Path, opts.IsDir)
+	//if exists {
+	//	err := RefreshFileInfo(opts)
+	//	if err != nil {
+	//		return info, err
+	//	}
+	//	if opts.Content {
+	//		content := ""
+	//		content, err = getContent(opts.Path)
+	//		if err != nil {
+	//			return info, err
+	//		}
+	//		info.Content = content
+	//	}
+	//	return info, nil
+	//}
+
+	err = index.RefreshFileInfo(opts)
 	if err != nil {
-		return nil, err
+		return response, err
 	}
-	info, exists = index.GetReducedMetadata(opts.Path, opts.IsDir)
+	info, exists := index.GetReducedMetadata(opts.Path, opts.IsDir)
 	if !exists {
-		return nil, err
+		return response, err
 	}
 	if opts.Content {
 		content, err := getContent(opts.Path)
 		if err != nil {
-			return info, err
+			return response, err
 		}
-		info.Content = content
+		response.Content = content
 	}
-	return info, nil
-}
-
-func RefreshFileInfo(opts FileOptions) error {
-	refreshOptions := FileOptions{
-		Path:  opts.Path,
-		IsDir: opts.IsDir,
-		Token: opts.Token,
-	}
-	index := GetIndex(rootPath)
-
-	if !refreshOptions.IsDir {
-		refreshOptions.Path = index.makeIndexPath(filepath.Dir(refreshOptions.Path))
-		refreshOptions.IsDir = true
-	} else {
-		refreshOptions.Path = index.makeIndexPath(refreshOptions.Path)
-	}
-
-	current, exists := index.GetMetadataInfo(refreshOptions.Path, true)
-
-	file, err := stat(refreshOptions)
-	if err != nil {
-		return fmt.Errorf("file/folder does not exist to refresh data: %s", refreshOptions.Path)
-	}
-
-	//utils.PrintStructFields(*file)
-	result := index.UpdateMetadata(file)
-	if !result {
-		return fmt.Errorf("file/folder does not exist in metadata: %s", refreshOptions.Path)
-	}
-	if !exists {
-		return nil
-	}
-	if current.Size != file.Size {
-		index.recursiveUpdateDirSizes(filepath.Dir(refreshOptions.Path), file, current.Size)
-	}
-	return nil
-}
-
-func stat(opts FileOptions) (*FileInfo, error) {
-	realPath, _, err := GetRealPath(rootPath, opts.Path)
-	if err != nil {
-		return nil, err
-	}
-	info, err := os.Lstat(realPath)
-	if err != nil {
-		return nil, err
-	}
-	file := &FileInfo{
-		Path:      opts.Path,
-		Name:      filepath.Base(opts.Path),
-		ModTime:   info.ModTime(),
-		Mode:      info.Mode(),
-		Size:      info.Size(),
-		Extension: filepath.Ext(info.Name()),
-		Token:     opts.Token,
-	}
-	if info.IsDir() {
-		// Open and read directory contents
-		dir, err := os.Open(realPath)
-		if err != nil {
-			return nil, err
-		}
-		defer dir.Close()
-
-		dirInfo, err := dir.Stat()
-		if err != nil {
-			return nil, err
-		}
-		index := GetIndex(rootPath)
-		// Check cached metadata to decide if refresh is needed
-		cachedParentDir, exists := index.GetMetadataInfo(opts.Path, true)
-		if exists && dirInfo.ModTime().Before(cachedParentDir.CacheTime) {
-			return cachedParentDir, nil
-		}
-
-		// Read directory contents and process
-		files, err := dir.Readdir(-1)
-		if err != nil {
-			return nil, err
-		}
-
-		file.Files = []ReducedItem{}
-		file.Dirs = map[string]*FileInfo{}
-
-		var totalSize int64
-		for _, item := range files {
-			itemPath := filepath.Join(realPath, item.Name())
-
-			if item.IsDir() {
-				itemInfo := &FileInfo{
-					Name:    item.Name(),
-					ModTime: item.ModTime(),
-					Mode:    item.Mode(),
-				}
-
-				if exists {
-					// if directory size was already cached use that.
-					cachedDir, ok := cachedParentDir.Dirs[item.Name()]
-					if ok {
-						itemInfo.Size = cachedDir.Size
-					}
-				}
-				file.Dirs[item.Name()] = itemInfo
-				totalSize += itemInfo.Size
-			} else {
-				itemInfo := ReducedItem{
-					Name:    item.Name(),
-					Size:    item.Size(),
-					ModTime: item.ModTime(),
-					Mode:    item.Mode(),
-				}
-				if IsSymlink(item.Mode()) {
-					itemInfo.Type = "symlink"
-					info, err := os.Stat(itemPath)
-					if err == nil {
-						itemInfo.Name = info.Name()
-						itemInfo.ModTime = info.ModTime()
-						itemInfo.Size = info.Size()
-						itemInfo.Mode = info.Mode()
-					} else {
-						file.Type = "invalid_link"
-					}
-				}
-				if file.Type != "invalid_link" {
-					err := itemInfo.detectType(itemPath, true, opts.Content, opts.ReadHeader)
-					if err != nil {
-						fmt.Printf("failed to detect type for %v: %v \n", itemPath, err)
-					}
-					file.Files = append(file.Files, itemInfo)
-				}
-				totalSize += itemInfo.Size
-
-			}
-		}
-
-		file.Size = totalSize
-	}
-	return file, nil
+	response.FileInfo = info
+	return response, nil
 }
 
 // Checksum checksums a given File for a given User, using a specific
 // algorithm. The checksums data is saved on File object.
-func (i *FileInfo) Checksum(algo string) error {
-
-	if i.Checksums == nil {
-		i.Checksums = map[string]string{}
-	}
-	fullpath := filepath.Join(i.Path, i.Name)
-	reader, err := os.Open(fullpath)
+func GetChecksum(fullPath, algo string) (map[string]string, error) {
+	subs := map[string]string{}
+	reader, err := os.Open(fullPath)
 	if err != nil {
-		return err
+		return subs, err
 	}
 	defer reader.Close()
 
@@ -287,21 +149,21 @@ func (i *FileInfo) Checksum(algo string) error {
 
 	h, ok := hashFuncs[algo]
 	if !ok {
-		return errors.ErrInvalidOption
+		return subs, errors.ErrInvalidOption
 	}
 
 	_, err = io.Copy(h, reader)
 	if err != nil {
-		return err
+		return subs, err
 	}
-
-	i.Checksums[algo] = hex.EncodeToString(h.Sum(nil))
-	return nil
+	subs[algo] = hex.EncodeToString(h.Sum(nil))
+	return subs, nil
 }
 
 // RealPath gets the real path for the file, resolving symlinks if supported.
 func (i *FileInfo) RealPath() string {
-	realPath, err := filepath.EvalSymlinks(i.Path)
+	realPath, _, _ := GetRealPath(rootPath, i.Path)
+	realPath, err := filepath.EvalSymlinks(realPath)
 	if err == nil {
 		return realPath
 	}
@@ -314,13 +176,24 @@ func GetRealPath(relativePath ...string) (string, bool, error) {
 		combined = append(combined, strings.TrimPrefix(path, settings.Config.Server.Root))
 	}
 	joinedPath := filepath.Join(combined...)
+
+	isDir, _ := utils.RealPathCache.Get(joinedPath + ":isdir").(bool)
+	cached, ok := utils.RealPathCache.Get(joinedPath).(string)
+	if ok && cached != "" {
+		return cached, isDir, nil
+	}
 	// Convert relative path to absolute path
 	absolutePath, err := filepath.Abs(joinedPath)
 	if err != nil {
 		return absolutePath, false, fmt.Errorf("could not get real path: %v, %s", combined, err)
 	}
 	// Resolve symlinks and get the real path
-	return resolveSymlinks(absolutePath)
+	realPath, isDir, err := resolveSymlinks(absolutePath)
+	if err == nil {
+		utils.RealPathCache.Set(joinedPath, realPath)
+		utils.RealPathCache.Set(joinedPath+":isdir", isDir)
+	}
+	return realPath, isDir, err
 }
 
 func DeleteFiles(absPath string, opts FileOptions) error {
@@ -328,7 +201,9 @@ func DeleteFiles(absPath string, opts FileOptions) error {
 	if err != nil {
 		return err
 	}
-	err = RefreshFileInfo(opts)
+	index := GetIndex(rootPath)
+	refreshConfig := FileOptions{Path: filepath.Dir(opts.Path), IsDir: true}
+	err = index.RefreshFileInfo(refreshConfig)
 	if err != nil {
 		return err
 	}
@@ -340,8 +215,9 @@ func MoveResource(realsrc, realdst string, isSrcDir bool) error {
 	if err != nil {
 		return err
 	}
+	index := GetIndex(rootPath)
 	// refresh info for source and dest
-	err = RefreshFileInfo(FileOptions{
+	err = index.RefreshFileInfo(FileOptions{
 		Path:  realsrc,
 		IsDir: isSrcDir,
 	})
@@ -352,7 +228,7 @@ func MoveResource(realsrc, realdst string, isSrcDir bool) error {
 	if !isSrcDir {
 		refreshConfig.Path = filepath.Dir(realdst)
 	}
-	err = RefreshFileInfo(refreshConfig)
+	err = index.RefreshFileInfo(refreshConfig)
 	if err != nil {
 		return errors.ErrEmptyKey
 	}
@@ -364,12 +240,12 @@ func CopyResource(realsrc, realdst string, isSrcDir bool) error {
 	if err != nil {
 		return err
 	}
-
+	index := GetIndex(rootPath)
 	refreshConfig := FileOptions{Path: realdst, IsDir: true}
 	if !isSrcDir {
 		refreshConfig.Path = filepath.Dir(realdst)
 	}
-	err = RefreshFileInfo(refreshConfig)
+	err = index.RefreshFileInfo(refreshConfig)
 	if err != nil {
 		return errors.ErrEmptyKey
 	}
@@ -383,7 +259,8 @@ func WriteDirectory(opts FileOptions) error {
 	if err != nil {
 		return err
 	}
-	err = RefreshFileInfo(opts)
+	index := GetIndex(rootPath)
+	err = index.RefreshFileInfo(opts)
 	if err != nil {
 		return errors.ErrEmptyKey
 	}
@@ -391,13 +268,10 @@ func WriteDirectory(opts FileOptions) error {
 }
 
 func WriteFile(opts FileOptions, in io.Reader) error {
-	dst := opts.Path
+	dst, _, _ := GetRealPath(rootPath, opts.Path)
 	parentDir := filepath.Dir(dst)
-	// Split the directory from the destination path
-	dir := filepath.Dir(dst)
-
 	// Create the directory and all necessary parents
-	err := os.MkdirAll(dir, 0775)
+	err := os.MkdirAll(parentDir, 0775)
 	if err != nil {
 		return err
 	}
@@ -415,35 +289,35 @@ func WriteFile(opts FileOptions, in io.Reader) error {
 		return err
 	}
 	opts.Path = parentDir
-	err = RefreshFileInfo(opts)
-	if err != nil {
-		return errors.ErrEmptyKey
-	}
-	return nil
+	opts.IsDir = true
+	index := GetIndex(rootPath)
+	return index.RefreshFileInfo(opts)
 }
 
 // resolveSymlinks resolves symlinks in the given path
 func resolveSymlinks(path string) (string, bool, error) {
 	for {
-		// Get the file info
+		// Get the file info using os.Lstat to handle symlinks
 		info, err := os.Lstat(path)
 		if err != nil {
-			return path, false, fmt.Errorf("could not stat path: %v, %s", path, err)
+			return path, false, fmt.Errorf("could not stat path: %s, %v", path, err)
 		}
 
-		// Check if it's a symlink
+		// Check if the path is a symlink
 		if info.Mode()&os.ModeSymlink != 0 {
 			// Read the symlink target
 			target, err := os.Readlink(path)
 			if err != nil {
-				return path, false, err
+				return path, false, fmt.Errorf("could not read symlink: %s, %v", path, err)
 			}
 
-			// Resolve the target relative to the symlink's directory
+			// Resolve the symlink's target relative to its directory
+			// This ensures the resolved path is absolute and correctly calculated
 			path = filepath.Join(filepath.Dir(path), target)
 		} else {
-			// Not a symlink, so return the resolved path and check if it's a directory
-			return path, info.IsDir(), nil
+			// Not a symlink, so return the resolved path and whether it's a directory
+			isDir := info.IsDir()
+			return path, isDir, nil
 		}
 	}
 }
@@ -461,7 +335,7 @@ func getContent(path string) (string, error) {
 	}
 	stringContent := string(content)
 	if !utf8.ValidString(stringContent) {
-		return "", fmt.Errorf("file is not utf8 encoded")
+		return "", nil
 	}
 	if stringContent == "" {
 		return "empty-file-x6OlSil", nil
@@ -469,88 +343,32 @@ func getContent(path string) (string, error) {
 	return stringContent, nil
 }
 
-// detectType detects the file type.
-func (i *ReducedItem) detectType(path string, modify, saveContent, readHeader bool) error {
+// DetectType detects the MIME type of a file and updates the ItemInfo struct.
+func (i *ItemInfo) DetectType(path string, saveContent bool) {
 	name := i.Name
-	var contentErr error
-	var contentString string
-	if saveContent {
-		contentString, contentErr = getContent(path)
-		if contentErr == nil {
-			i.Content = contentString
-		}
-	}
-
-	if IsNamedPipe(i.Mode) {
-		i.Type = "blob"
-		return contentErr
-	}
-
 	ext := filepath.Ext(name)
-	var buffer []byte
-	if readHeader {
-		buffer = i.readFirstBytes(path)
-		mimetype := mime.TypeByExtension(ext)
-		if mimetype == "" {
-			http.DetectContentType(buffer)
-		}
-	}
 
-	for _, fileType := range AllFiletypeOptions {
-		if IsMatchingType(ext, fileType) {
-			i.Type = fileType
-		}
-		switch i.Type {
-		case "text":
-			if !modify {
-				i.Type = "textImmutable"
-			}
-			if saveContent {
-				return contentErr
-			}
-		case "video":
-			// TODO add back somewhere else, not during metadata fetch
-			//parentDir := strings.TrimRight(path, name)
-			//i.detectSubtitles(parentDir)
-		case "doc":
-			if ext == ".pdf" {
-				i.Type = "pdf"
-				return nil
-			}
-			if saveContent {
-				return nil
-			}
-		}
-	}
+	// Attempt MIME detection by file extension
+	i.Type = strings.Split(mime.TypeByExtension(ext), ";")[0]
 	if i.Type == "" {
-		i.Type = "blob"
-		if saveContent {
-			return contentErr
+		i.Type = extendedMimeTypeCheck(ext)
+	}
+	if i.Type == "blob" {
+		realpath, _, _ := GetRealPath(path)
+		// Read only the first 512 bytes for efficient MIME detection
+		file, err := os.Open(realpath)
+		if err != nil {
+
+		} else {
+			defer file.Close()
+			buffer := make([]byte, 512)
+			n, _ := file.Read(buffer) // Ignore errors from Read
+			i.Type = strings.Split(http.DetectContentType(buffer[:n]), ";")[0]
 		}
 	}
-
-	return nil
-}
-
-// readFirstBytes reads the first bytes of the file.
-func (i *ReducedItem) readFirstBytes(path string) []byte {
-	file, err := os.Open(path)
-	if err != nil {
-		i.Type = "blob"
-		return nil
-	}
-	defer file.Close()
-
-	buffer := make([]byte, 512) //nolint:gomnd
-	n, err := file.Read(buffer)
-	if err != nil && err != io.EOF {
-		i.Type = "blob"
-		return nil
-	}
-
-	return buffer[:n]
 }
 
+// TODO add subtitles back
 // detectSubtitles detects subtitles for video files.
 //func (i *FileInfo) detectSubtitles(path string) {
 //	if i.Type != "video" {
@@ -620,3 +438,26 @@ func Exists(path string) bool {
 	}
 	return false
 }
+
+func (info *FileInfo) SortItems() {
+	sort.Slice(info.Folders, func(i, j int) bool {
+		// Convert strings to integers for numeric sorting if both are numeric
+		numI, errI := strconv.Atoi(info.Folders[i].Name)
+		numJ, errJ := strconv.Atoi(info.Folders[j].Name)
+		if errI == nil && errJ == nil {
+			return numI < numJ
+		}
+		// Fallback to case-insensitive lexicographical sorting
+		return strings.ToLower(info.Folders[i].Name) < strings.ToLower(info.Folders[j].Name)
+	})
+	sort.Slice(info.Files, func(i, j int) bool {
+		// Convert strings to integers for numeric sorting if both are numeric
+		numI, errI := strconv.Atoi(info.Files[i].Name)
+		numJ, errJ := strconv.Atoi(info.Files[j].Name)
+		if errI == nil && errJ == nil {
+			return numI < numJ
+		}
+		// Fallback to case-insensitive lexicographical sorting
+		return strings.ToLower(info.Files[i].Name) < strings.ToLower(info.Files[j].Name)
+	})
+}

backend/files/file_test.go

@@ -3,6 +3,7 @@ package files
 import (
 	"os"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"testing"
 )
@@ -71,3 +72,98 @@ func Test_GetRealPath(t *testing.T) {
 		})
 	}
 }
+
+func TestSortItems(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    FileInfo
+		expected FileInfo
+	}{
+		{
+			name: "Numeric and Lexicographical Sorting",
+			input: FileInfo{
+				Folders: []ItemInfo{
+					{Name: "10"},
+					{Name: "2"},
+					{Name: "apple"},
+					{Name: "Banana"},
+				},
+				Files: []ItemInfo{
+					{Name: "File2"},
+					{Name: "File10"},
+					{Name: "File1"},
+					{Name: "banana"},
+				},
+			},
+			expected: FileInfo{
+				Folders: []ItemInfo{
+					{Name: "2"},
+					{Name: "10"},
+					{Name: "apple"},
+					{Name: "Banana"},
+				},
+				Files: []ItemInfo{
+					{Name: "banana"},
+					{Name: "File1"},
+					{Name: "File10"},
+					{Name: "File2"},
+				},
+			},
+		},
+		{
+			name: "Only Lexicographical Sorting",
+			input: FileInfo{
+				Folders: []ItemInfo{
+					{Name: "dog"},
+					{Name: "Cat"},
+					{Name: "apple"},
+				},
+				Files: []ItemInfo{
+					{Name: "Zebra"},
+					{Name: "apple"},
+					{Name: "cat"},
+				},
+			},
+			expected: FileInfo{
+				Folders: []ItemInfo{
+					{Name: "apple"},
+					{Name: "Cat"},
+					{Name: "dog"},
+				},
+				Files: []ItemInfo{
+					{Name: "apple"},
+					{Name: "cat"},
+					{Name: "Zebra"},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			test.input.SortItems()
+
+			getNames := func(items []ItemInfo) []string {
+				names := []string{}
+				for _, folder := range items {
+					names = append(names, folder.Name)
+				}
+				return names
+			}
+
+			actualFolderNames := getNames(test.input.Folders)
+			expectedFolderNames := getNames(test.expected.Folders)
+
+			if !reflect.DeepEqual(actualFolderNames, expectedFolderNames) {
+				t.Errorf("Folders not sorted correctly.\nGot: %v\nExpected: %v", actualFolderNames, expectedFolderNames)
+			}
+
+			actualFileNames := getNames(test.input.Files)
+			expectedFileNames := getNames(test.expected.Files)
+
+			if !reflect.DeepEqual(actualFileNames, expectedFileNames) {
+				t.Errorf("Files not sorted correctly.\nGot: %v\nExpected: %v", actualFileNames, expectedFileNames)
+			}
+		})
+	}
+}

backend/files/indexing.go

@@ -1,204 +0,0 @@
-package files
-
-import (
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/gtsteffaniak/filebrowser/settings"
-)
-
-type Index struct {
-	Root        string
-	Directories map[string]*FileInfo
-	NumDirs     int
-	NumFiles    int
-	inProgress  bool
-	LastIndexed time.Time
-	mu          sync.RWMutex
-}
-
-var (
-	rootPath     string = "/srv"
-	indexes      []*Index
-	indexesMutex sync.RWMutex
-)
-
-func InitializeIndex(intervalMinutes uint32, schedule bool) {
-	if schedule {
-		go indexingScheduler(intervalMinutes)
-	}
-}
-
-func indexingScheduler(intervalMinutes uint32) {
-	if settings.Config.Server.Root != "" {
-		rootPath = settings.Config.Server.Root
-	}
-	si := GetIndex(rootPath)
-	for {
-		startTime := time.Now()
-		// Set the indexing flag to indicate that indexing is in progress
-		si.resetCount()
-		// Perform the indexing operation
-		err := si.indexFiles("/")
-		// Reset the indexing flag to indicate that indexing has finished
-		si.inProgress = false
-		// Update the LastIndexed time
-		si.LastIndexed = time.Now()
-		if err != nil {
-			log.Printf("Error during indexing: %v", err)
-		}
-		if si.NumFiles+si.NumDirs > 0 {
-			timeIndexedInSeconds := int(time.Since(startTime).Seconds())
-			log.Println("Successfully indexed files.")
-			log.Printf("Time spent indexing: %v seconds\n", timeIndexedInSeconds)
-			log.Printf("Files found: %v\n", si.NumFiles)
-			log.Printf("Directories found: %v\n", si.NumDirs)
-		}
-		// Sleep for the specified interval
-		time.Sleep(time.Duration(intervalMinutes) * time.Minute)
-	}
-}
-
-// Define a function to recursively index files and directories
-func (si *Index) indexFiles(adjustedPath string) error {
-	realPath := strings.TrimRight(si.Root, "/") + adjustedPath
-
-	// Open the directory
-	dir, err := os.Open(realPath)
-	if err != nil {
-		si.RemoveDirectory(adjustedPath) // Remove if it can't be opened
-		return err
-	}
-	defer dir.Close()
-
-	dirInfo, err := dir.Stat()
-	if err != nil {
-		return err
-	}
-
-	// Skip directories that haven't been modified since the last index
-	if dirInfo.ModTime().Before(si.LastIndexed) {
-		return nil
-	}
-
-	// Read directory contents
-	files, err := dir.Readdir(-1)
-	if err != nil {
-		return err
-	}
-
-	var totalSize int64
-	var numDirs, numFiles int
-	fileInfos := []ReducedItem{}
-	dirInfos := map[string]*FileInfo{}
-	combinedPath := adjustedPath + "/"
-	if adjustedPath == "/" {
-		combinedPath = "/"
-	}
-
-	// Process each file and directory in the current directory
-	for _, file := range files {
-		itemInfo := &FileInfo{
-			ModTime: file.ModTime(),
-		}
-		if file.IsDir() {
-			itemInfo.Name = file.Name()
-			itemInfo.Path = combinedPath + file.Name()
-			// Recursively index the subdirectory
-			err := si.indexFiles(itemInfo.Path)
-			if err != nil {
-				log.Printf("Failed to index directory %s: %v", itemInfo.Path, err)
-				continue
-			}
-			// Fetch the metadata for the subdirectory after indexing
-			subDirInfo, exists := si.GetMetadataInfo(itemInfo.Path, true)
-			if exists {
-				itemInfo.Size = subDirInfo.Size
-				totalSize += subDirInfo.Size // Add subdirectory size to the total
-			}
-			dirInfos[itemInfo.Name] = itemInfo
-			numDirs++
-		} else {
-			itemInfo := &ReducedItem{
-				Name:    file.Name(),
-				ModTime: file.ModTime(),
-				Size:    file.Size(),
-				Mode:    file.Mode(),
-			}
-			_ = itemInfo.detectType(combinedPath+file.Name(), true, false, false)
-			fileInfos = append(fileInfos, *itemInfo)
-			totalSize += itemInfo.Size
-			numFiles++
-		}
-	}
-
-	// Create FileInfo for the current directory
-	dirFileInfo := &FileInfo{
-		Path:    adjustedPath,
-		Files:   fileInfos,
-		Dirs:    dirInfos,
-		Size:    totalSize,
-		ModTime: dirInfo.ModTime(),
-	}
-
-	// Update the current directory metadata in the index
-	si.UpdateMetadata(dirFileInfo)
-	si.NumDirs += numDirs
-	si.NumFiles += numFiles
-
-	return nil
-}
-
-func (si *Index) makeIndexPath(subPath string) string {
-	if strings.HasPrefix(subPath, "./") {
-		subPath = strings.TrimPrefix(subPath, ".")
-	}
-	if strings.HasPrefix(subPath, ".") || si.Root == subPath {
-		return "/"
-	}
-	// clean path
-	subPath = strings.TrimSuffix(subPath, "/")
-	// remove index prefix
-	adjustedPath := strings.TrimPrefix(subPath, si.Root)
-	// remove trailing slash
-	adjustedPath = strings.TrimSuffix(adjustedPath, "/")
-	if !strings.HasPrefix(adjustedPath, "/") {
-		adjustedPath = "/" + adjustedPath
-	}
-	return adjustedPath
-}
-
-//func getParentPath(path string) string {
-//	// Trim trailing slash for consistency
-//	path = strings.TrimSuffix(path, "/")
-//	if path == "" || path == "/" {
-//		return "" // Root has no parent
-//	}
-//
-//	lastSlash := strings.LastIndex(path, "/")
-//	if lastSlash == -1 {
-//		return "/" // Parent of a top-level directory
-//	}
-//	return path[:lastSlash]
-//}
-
-func (si *Index) recursiveUpdateDirSizes(parentDir string, childInfo *FileInfo, previousSize int64) {
-	childDirName := filepath.Base(childInfo.Path)
-	if parentDir == childDirName {
-		return
-	}
-	dir, exists := si.GetMetadataInfo(parentDir, true)
-	if !exists {
-		return
-	}
-	dir.Dirs[childDirName] = childInfo
-	newSize := dir.Size - previousSize + childInfo.Size
-	dir.Size += newSize
-	si.UpdateMetadata(dir)
-	dir, _ = si.GetMetadataInfo(parentDir, true)
-	si.recursiveUpdateDirSizes(filepath.Dir(parentDir), dir, newSize)
-}

backend/files/indexingFiles.go

@@ -0,0 +1,229 @@
+package files
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
+)
+
+type Index struct {
+	Root                       string
+	Directories                map[string]*FileInfo
+	NumDirs                    uint64
+	NumFiles                   uint64
+	NumDeleted                 uint64
+	FilesChangedDuringIndexing bool
+	currentSchedule            int
+	assessment                 string
+	indexingTime               int
+	LastIndexed                time.Time
+	SmartModifier              time.Duration
+	mu                         sync.RWMutex
+	scannerMu                  sync.Mutex
+}
+
+var (
+	rootPath     string = "/srv"
+	indexes      []*Index
+	indexesMutex sync.RWMutex
+)
+
+func InitializeIndex(enabled bool) {
+	if enabled {
+		time.Sleep(time.Second)
+		if settings.Config.Server.Root != "" {
+			rootPath = settings.Config.Server.Root
+		}
+		si := GetIndex(rootPath)
+		log.Println("Initializing index and assessing file system complexity")
+		si.RunIndexing("/", false)
+		go si.setupIndexingScanners()
+	}
+}
+
+// Define a function to recursively index files and directories
+func (si *Index) indexDirectory(adjustedPath string, quick, recursive bool) error {
+	realPath := strings.TrimRight(si.Root, "/") + adjustedPath
+
+	// Open the directory
+	dir, err := os.Open(realPath)
+	if err != nil {
+		si.RemoveDirectory(adjustedPath) // Remove, must have been deleted
+		return err
+	}
+	defer dir.Close()
+
+	dirInfo, err := dir.Stat()
+	if err != nil {
+		return err
+	}
+	combinedPath := adjustedPath + "/"
+	if adjustedPath == "/" {
+		combinedPath = "/"
+	}
+	// get whats currently in cache
+	si.mu.RLock()
+	cacheDirItems := []ItemInfo{}
+	modChange := true // default to true
+	cachedDir, exists := si.Directories[adjustedPath]
+	if exists && quick {
+		modChange = dirInfo.ModTime() != cachedDir.ModTime
+		cacheDirItems = cachedDir.Folders
+	}
+	si.mu.RUnlock()
+
+	// If the directory has not been modified since the last index, skip expensive readdir
+	// recursively check cached dirs for mod time changes as well
+	if !modChange && recursive {
+		for _, item := range cacheDirItems {
+			err = si.indexDirectory(combinedPath+item.Name, quick, true)
+			if err != nil {
+				fmt.Printf("error indexing directory %v : %v", combinedPath+item.Name, err)
+			}
+		}
+		return nil
+	}
+
+	if quick {
+		si.mu.Lock()
+		si.FilesChangedDuringIndexing = true
+		si.mu.Unlock()
+	}
+
+	// Read directory contents
+	files, err := dir.Readdir(-1)
+	if err != nil {
+		return err
+	}
+
+	var totalSize int64
+	fileInfos := []ItemInfo{}
+	dirInfos := []ItemInfo{}
+
+	// Process each file and directory in the current directory
+	for _, file := range files {
+		itemInfo := &ItemInfo{
+			Name:    file.Name(),
+			ModTime: file.ModTime(),
+		}
+		if file.IsDir() {
+			dirPath := combinedPath + file.Name()
+			if recursive {
+				// Recursively index the subdirectory
+				err = si.indexDirectory(dirPath, quick, recursive)
+				if err != nil {
+					log.Printf("Failed to index directory %s: %v", dirPath, err)
+					continue
+				}
+			}
+			realDirInfo, exists := si.GetMetadataInfo(dirPath, true)
+			if exists {
+				itemInfo.Size = realDirInfo.Size
+			}
+			totalSize += itemInfo.Size
+			itemInfo.Type = "directory"
+			dirInfos = append(dirInfos, *itemInfo)
+			si.NumDirs++
+		} else {
+			itemInfo.DetectType(combinedPath+file.Name(), false)
+			itemInfo.Size = file.Size()
+			fileInfos = append(fileInfos, *itemInfo)
+			totalSize += itemInfo.Size
+			si.NumFiles++
+		}
+	}
+	// Create FileInfo for the current directory
+	dirFileInfo := &FileInfo{
+		Path:    adjustedPath,
+		Files:   fileInfos,
+		Folders: dirInfos,
+	}
+	dirFileInfo.ItemInfo = ItemInfo{
+		Name:    dirInfo.Name(),
+		Type:    "directory",
+		Size:    totalSize,
+		ModTime: dirInfo.ModTime(),
+	}
+
+	dirFileInfo.SortItems()
+
+	// Update the current directory metadata in the index
+	si.UpdateMetadata(dirFileInfo)
+
+	return nil
+}
+
+func (si *Index) makeIndexPath(subPath string) string {
+	if strings.HasPrefix(subPath, "./") {
+		subPath = strings.TrimPrefix(subPath, ".")
+	}
+	if si.Root == subPath || subPath == "." {
+		return "/"
+	}
+	// clean path
+	subPath = strings.TrimSuffix(subPath, "/")
+	// remove index prefix
+	adjustedPath := strings.TrimPrefix(subPath, si.Root)
+	// remove trailing slash
+	adjustedPath = strings.TrimSuffix(adjustedPath, "/")
+	if !strings.HasPrefix(adjustedPath, "/") {
+		adjustedPath = "/" + adjustedPath
+	}
+	return adjustedPath
+}
+
+func (si *Index) recursiveUpdateDirSizes(childInfo *FileInfo, previousSize int64) {
+	parentDir := utils.GetParentDirectoryPath(childInfo.Path)
+	parentInfo, exists := si.GetMetadataInfo(parentDir, true)
+	if !exists || parentDir == "" {
+		return
+	}
+	newSize := parentInfo.Size - previousSize + childInfo.Size
+	parentInfo.Size += newSize
+	si.UpdateMetadata(parentInfo)
+	si.recursiveUpdateDirSizes(parentInfo, newSize)
+}
+
+func (si *Index) RefreshFileInfo(opts FileOptions) error {
+	refreshOptions := FileOptions{
+		Path:  opts.Path,
+		IsDir: opts.IsDir,
+	}
+
+	if !refreshOptions.IsDir {
+		refreshOptions.Path = si.makeIndexPath(filepath.Dir(refreshOptions.Path))
+		refreshOptions.IsDir = true
+	} else {
+		refreshOptions.Path = si.makeIndexPath(refreshOptions.Path)
+	}
+	err := si.indexDirectory(refreshOptions.Path, false, false)
+	if err != nil {
+		return fmt.Errorf("file/folder does not exist to refresh data: %s", refreshOptions.Path)
+	}
+	file, exists := si.GetMetadataInfo(refreshOptions.Path, true)
+	if !exists {
+		return fmt.Errorf("file/folder does not exist in metadata: %s", refreshOptions.Path)
+	}
+
+	current, firstExisted := si.GetMetadataInfo(refreshOptions.Path, true)
+	refreshParentInfo := firstExisted && current.Size != file.Size
+	//utils.PrintStructFields(*file)
+	result := si.UpdateMetadata(file)
+	if !result {
+		return fmt.Errorf("file/folder does not exist in metadata: %s", refreshOptions.Path)
+	}
+	if !exists {
+		return nil
+	}
+	if refreshParentInfo {
+		si.recursiveUpdateDirSizes(file, current.Size)
+	}
+	return nil
+}

backend/files/indexingSchedule.go

@@ -0,0 +1,117 @@
+package files
+
+import (
+	"log"
+	"time"
+
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+)
+
+// schedule in minutes
+var scanSchedule = []time.Duration{
+	5 * time.Minute, // 5 minute quick scan & 25 minutes for a full scan
+	10 * time.Minute,
+	20 * time.Minute, // [3] element is 20 minutes, reset anchor for full scan
+	40 * time.Minute,
+	1 * time.Hour,
+	2 * time.Hour,
+	3 * time.Hour,
+	4 * time.Hour, // 4 hours for quick scan & 20 hours for a full scan
+}
+
+func (si *Index) newScanner(origin string) {
+	fullScanAnchor := 3
+	fullScanCounter := 0 // every 5th scan is a full scan
+	for {
+		// Determine sleep time with modifiers
+		fullScanCounter++
+		sleepTime := scanSchedule[si.currentSchedule] + si.SmartModifier
+		if si.assessment == "simple" {
+			sleepTime = scanSchedule[si.currentSchedule] - si.SmartModifier
+		}
+		if settings.Config.Server.IndexingInterval > 0 {
+			sleepTime = time.Duration(settings.Config.Server.IndexingInterval) * time.Minute
+		}
+
+		// Log and sleep before indexing
+		log.Printf("Next scan in %v\n", sleepTime)
+		time.Sleep(sleepTime)
+
+		si.scannerMu.Lock()
+		if fullScanCounter == 5 {
+			si.RunIndexing(origin, false) // Full scan
+			fullScanCounter = 0
+		} else {
+			si.RunIndexing(origin, true) // Quick scan
+		}
+		si.scannerMu.Unlock()
+
+		// Adjust schedule based on file changes
+		if si.FilesChangedDuringIndexing {
+			// Move to at least the full-scan anchor or reduce interval
+			if si.currentSchedule > fullScanAnchor {
+				si.currentSchedule = fullScanAnchor
+			} else if si.currentSchedule > 0 {
+				si.currentSchedule--
+			}
+		} else {
+			// Increment toward the longest interval if no changes
+			if si.currentSchedule < len(scanSchedule)-1 {
+				si.currentSchedule++
+			}
+		}
+		if si.assessment == "simple" && si.currentSchedule > 3 {
+			si.currentSchedule = 3
+		}
+		// Ensure `currentSchedule` stays within bounds
+		if si.currentSchedule < 0 {
+			si.currentSchedule = 0
+		} else if si.currentSchedule >= len(scanSchedule) {
+			si.currentSchedule = len(scanSchedule) - 1
+		}
+	}
+}
+
+func (si *Index) RunIndexing(origin string, quick bool) {
+	prevNumDirs := si.NumDirs
+	prevNumFiles := si.NumFiles
+	if quick {
+		log.Println("Starting quick scan")
+	} else {
+		log.Println("Starting full scan")
+		si.NumDirs = 0
+		si.NumFiles = 0
+	}
+	startTime := time.Now()
+	si.FilesChangedDuringIndexing = false
+	// Perform the indexing operation
+	err := si.indexDirectory("/", quick, true)
+	if err != nil {
+		log.Printf("Error during indexing: %v", err)
+	}
+	// Update the LastIndexed time
+	si.LastIndexed = time.Now()
+	si.indexingTime = int(time.Since(startTime).Seconds())
+	if !quick {
+		// update smart indexing
+		if si.indexingTime < 3 || si.NumDirs < 10000 {
+			si.assessment = "simple"
+			si.SmartModifier = 4 * time.Minute
+		} else if si.indexingTime > 120 || si.NumDirs > 500000 {
+			si.assessment = "complex"
+			modifier := si.indexingTime / 10 // seconds
+			si.SmartModifier = time.Duration(modifier) * time.Minute
+		} else {
+			si.assessment = "normal"
+		}
+		log.Printf("Index assessment         : complexity=%v directories=%v files=%v \n", si.assessment, si.NumDirs, si.NumFiles)
+		if si.NumDirs != prevNumDirs || si.NumFiles != prevNumFiles {
+			si.FilesChangedDuringIndexing = true
+		}
+	}
+	log.Printf("Time Spent Indexing      : %v seconds\n", si.indexingTime)
+}
+
+func (si *Index) setupIndexingScanners() {
+	go si.newScanner("/")
+}

backend/files/indexing_test.go

@@ -3,16 +3,15 @@ package files
 import (
 	"encoding/json"
 	"math/rand"
-	"path/filepath"
 	"reflect"
 	"testing"
 	"time"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
 )
 
 func BenchmarkFillIndex(b *testing.B) {
-	InitializeIndex(5, false)
+	InitializeIndex(false)
 	si := GetIndex(settings.Config.Server.Root)
 	b.ResetTimer()
 	b.ReportAllocs()
@@ -24,11 +23,11 @@ func BenchmarkFillIndex(b *testing.B) {
 func (si *Index) createMockData(numDirs, numFilesPerDir int) {
 	for i := 0; i < numDirs; i++ {
 		dirPath := generateRandomPath(rand.Intn(3) + 1)
-		files := []ReducedItem{} // Slice of FileInfo
+		files := []ItemInfo{} // Slice of FileInfo
 
 		// Simulating files and directories with FileInfo
 		for j := 0; j < numFilesPerDir; j++ {
-			newFile := ReducedItem{
+			newFile := ItemInfo{
 				Name:    "file-" + getRandomTerm() + getRandomExtension(),
 				Size:    rand.Int63n(1000),                                          // Random size
 				ModTime: time.Now().Add(-time.Duration(rand.Intn(100)) * time.Hour), // Random mod time
@@ -37,7 +36,6 @@ func (si *Index) createMockData(numDirs, numFilesPerDir int) {
 			files = append(files, newFile)
 		}
 		dirInfo := &FileInfo{
-			Name:  filepath.Base(dirPath),
 			Path:  dirPath,
 			Files: files,
 		}
@@ -46,45 +44,6 @@ func (si *Index) createMockData(numDirs, numFilesPerDir int) {
 	}
 }
 
-func generateRandomPath(levels int) string {
-	rand.New(rand.NewSource(time.Now().UnixNano()))
-	dirName := "srv"
-	for i := 0; i < levels; i++ {
-		dirName += "/" + getRandomTerm()
-	}
-	return dirName
-}
-
-func getRandomTerm() string {
-	wordbank := []string{
-		"hi", "test", "other", "name",
-		"cool", "things", "more", "items",
-	}
-	rand.New(rand.NewSource(time.Now().UnixNano()))
-
-	index := rand.Intn(len(wordbank))
-	return wordbank[index]
-}
-
-func getRandomExtension() string {
-	wordbank := []string{
-		".txt", ".mp3", ".mov", ".doc",
-		".mp4", ".bak", ".zip", ".jpg",
-	}
-	rand.New(rand.NewSource(time.Now().UnixNano()))
-	index := rand.Intn(len(wordbank))
-	return wordbank[index]
-}
-
-func generateRandomSearchTerms(numTerms int) []string {
-	// Generate random search terms
-	searchTerms := make([]string, numTerms)
-	for i := 0; i < numTerms; i++ {
-		searchTerms[i] = getRandomTerm()
-	}
-	return searchTerms
-}
-
 // JSONBytesEqual compares the JSON in two byte slices.
 func JSONBytesEqual(a, b []byte) (bool, error) {
 	var j, j2 interface{}
@@ -113,36 +72,30 @@ func TestGetIndex(t *testing.T) {
 	}
 }
 
-func TestInitializeIndex(t *testing.T) {
-	type args struct {
-		intervalMinutes uint32
-	}
+func TestMakeIndexPath(t *testing.T) {
 	tests := []struct {
-		name string
-		args args
+		name     string
+		subPath  string
+		expected string
 	}{
-		// TODO: Add test cases.
+		{"Root path returns slash", "/", "/"},
+		{"Dot-prefixed returns slash", ".", "/"},
+		{"Double-dot prefix ignored", "./", "/"},
+		{"Dot prefix followed by text", "./test", "/test"},
+		{"Dot prefix followed by text", ".test", "/.test"},
+		{"Hidden file at root", "/.test", "/.test"},
+		{"Trailing slash removed", "/test/", "/test"},
+		{"Subpath without root prefix", "/other/test", "/other/test"},
+		{"Complex nested paths", "/nested/path", "/nested/path"},
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			InitializeIndex(tt.args.intervalMinutes, false)
-		})
-	}
-}
 
-func Test_indexingScheduler(t *testing.T) {
-	type args struct {
-		intervalMinutes uint32
-	}
-	tests := []struct {
-		name string
-		args args
-	}{
-		// TODO: Add test cases.
-	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			indexingScheduler(tt.args.intervalMinutes)
+			si := &Index{Root: "/"}
+			result := si.makeIndexPath(tt.subPath)
+			if result != tt.expected {
+				t.Errorf("makeIndexPath(%q) = %q; want %q", tt.name, result, tt.expected)
+			}
 		})
 	}
 }

backend/files/mockIndexing.go

@@ -0,0 +1,71 @@
+package files
+
+import (
+	"time"
+
+	"math/rand"
+)
+
+func CreateMockData(numDirs, numFilesPerDir int) FileInfo {
+	dir := FileInfo{}
+	dir.Path = "/here/is/your/mock/dir"
+	for i := 0; i < numDirs; i++ {
+		newFile := ItemInfo{
+			Name:    "file-" + getRandomTerm() + getRandomExtension(),
+			Size:    rand.Int63n(1000),                                          // Random size
+			ModTime: time.Now().Add(-time.Duration(rand.Intn(100)) * time.Hour), // Random mod time
+			Type:    "blob",
+		}
+		dir.Folders = append(dir.Folders, newFile)
+	}
+	// Simulating files and directories with FileInfo
+	for j := 0; j < numFilesPerDir; j++ {
+		newFile := ItemInfo{
+			Name:    "file-" + getRandomTerm() + getRandomExtension(),
+			Size:    rand.Int63n(1000),                                          // Random size
+			ModTime: time.Now().Add(-time.Duration(rand.Intn(100)) * time.Hour), // Random mod time
+			Type:    "blob",
+		}
+		dir.Files = append(dir.Files, newFile)
+	}
+	return dir
+}
+
+func generateRandomPath(levels int) string {
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	dirName := "srv"
+	for i := 0; i < levels; i++ {
+		dirName += "/" + getRandomTerm()
+	}
+	return dirName
+}
+
+func getRandomTerm() string {
+	wordbank := []string{
+		"hi", "test", "other", "name",
+		"cool", "things", "more", "items",
+	}
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	index := rand.Intn(len(wordbank))
+	return wordbank[index]
+}
+
+func getRandomExtension() string {
+	wordbank := []string{
+		".txt", ".mp3", ".mov", ".doc",
+		".mp4", ".bak", ".zip", ".jpg",
+	}
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	index := rand.Intn(len(wordbank))
+	return wordbank[index]
+}
+
+func generateRandomSearchTerms(numTerms int) []string {
+	// Generate random search terms
+	searchTerms := make([]string, numTerms)
+	for i := 0; i < numTerms; i++ {
+		searchTerms[i] = getRandomTerm()
+	}
+	return searchTerms
+}

backend/files/search.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 var (
@@ -14,21 +14,28 @@ var (
 	maxSearchResults  = 100
 )
 
-type searchResult struct {
+type SearchResult struct {
 	Path string `json:"path"`
 	Type string `json:"type"`
 	Size int64  `json:"size"`
 }
 
-func (si *Index) Search(search string, scope string, sourceSession string) []searchResult {
+func (si *Index) Search(search string, scope string, sourceSession string) []SearchResult {
 	// Remove slashes
 	scope = si.makeIndexPath(scope)
 	runningHash := utils.GenerateRandomHash(4)
 	sessionInProgress.Store(sourceSession, runningHash) // Store the value in the sync.Map
 	searchOptions := ParseSearch(search)
-	results := make(map[string]searchResult, 0)
+	results := make(map[string]SearchResult, 0)
 	count := 0
-	directories := si.getDirsInScope(scope)
+	var directories []string
+	cachedDirs, ok := utils.SearchResultsCache.Get(si.Root + scope).([]string)
+	if ok {
+		directories = cachedDirs
+	} else {
+		directories = si.getDirsInScope(scope)
+		utils.SearchResultsCache.Set(si.Root+scope, directories)
+	}
 	for _, searchTerm := range searchOptions.Terms {
 		if searchTerm == "" {
 			continue
@@ -38,6 +45,7 @@ func (si *Index) Search(search string, scope string, sourceSession string) []sea
 		}
 		si.mu.Lock()
 		for _, dirName := range directories {
+			scopedPath := strings.TrimPrefix(strings.TrimPrefix(dirName, scope), "/") + "/"
 			si.mu.Unlock()
 			dir, found := si.GetReducedMetadata(dirName, true)
 			si.mu.Lock()
@@ -47,38 +55,34 @@ func (si *Index) Search(search string, scope string, sourceSession string) []sea
 			if count > maxSearchResults {
 				break
 			}
-			reducedDir := ReducedItem{
+			reducedDir := ItemInfo{
 				Name: filepath.Base(dirName),
 				Type: "directory",
 				Size: dir.Size,
 			}
-
 			matches := reducedDir.containsSearchTerm(searchTerm, searchOptions)
 			if matches {
-				scopedPath := strings.TrimPrefix(strings.TrimPrefix(dirName, scope), "/") + "/"
-				results[scopedPath] = searchResult{Path: scopedPath, Type: "directory", Size: dir.Size}
+				results[scopedPath] = SearchResult{Path: scopedPath, Type: "directory", Size: dir.Size}
 				count++
 			}
-
 			// search files first
-			for _, item := range dir.Items {
-
+			for _, item := range dir.Files {
 				fullPath := dirName + "/" + item.Name
+				scopedPath := strings.TrimPrefix(strings.TrimPrefix(fullPath, scope), "/")
 				if item.Type == "directory" {
-					fullPath += "/"
+					scopedPath += "/"
 				}
 				value, found := sessionInProgress.Load(sourceSession)
 				if !found || value != runningHash {
 					si.mu.Unlock()
-					return []searchResult{}
+					return []SearchResult{}
 				}
 				if count > maxSearchResults {
 					break
 				}
 				matches := item.containsSearchTerm(searchTerm, searchOptions)
 				if matches {
-					scopedPath := strings.TrimPrefix(strings.TrimPrefix(fullPath, scope), "/")
-					results[scopedPath] = searchResult{Path: scopedPath, Type: item.Type, Size: item.Size}
+					results[scopedPath] = SearchResult{Path: scopedPath, Type: item.Type, Size: item.Size}
 					count++
 				}
 			}
@@ -87,7 +91,7 @@ func (si *Index) Search(search string, scope string, sourceSession string) []sea
 	}
 
 	// Sort keys based on the number of elements in the path after splitting by "/"
-	sortedKeys := make([]searchResult, 0, len(results))
+	sortedKeys := make([]SearchResult, 0, len(results))
 	for _, v := range results {
 		sortedKeys = append(sortedKeys, v)
 	}
@@ -103,7 +107,7 @@ func (si *Index) Search(search string, scope string, sourceSession string) []sea
 // returns true if the file name contains the search term
 // returns file type if the file name contains the search term
 // returns size of file/dir if the file name contains the search term
-func (fi ReducedItem) containsSearchTerm(searchTerm string, options *SearchOptions) bool {
+func (fi ItemInfo) containsSearchTerm(searchTerm string, options SearchOptions) bool {
 
 	fileTypes := map[string]bool{}
 	largerThan := int64(options.LargerThan) * 1024 * 1024

backend/files/search_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func BenchmarkSearchAllIndexes(b *testing.B) {
-	InitializeIndex(5, false)
+	InitializeIndex(false)
 	si := GetIndex(rootPath)
 
 	si.createMockData(50, 3) // 50 dirs, 3 files per dir
@@ -29,25 +29,25 @@ func BenchmarkSearchAllIndexes(b *testing.B) {
 func TestParseSearch(t *testing.T) {
 	tests := []struct {
 		input string
-		want  *SearchOptions
+		want  SearchOptions
 	}{
 		{
 			input: "my test search",
-			want: &SearchOptions{
+			want: SearchOptions{
 				Conditions: map[string]bool{"exact": false},
 				Terms:      []string{"my test search"},
 			},
 		},
 		{
 			input: "case:exact my|test|search",
-			want: &SearchOptions{
+			want: SearchOptions{
 				Conditions: map[string]bool{"exact": true},
 				Terms:      []string{"my", "test", "search"},
 			},
 		},
 		{
 			input: "type:largerThan=100 type:smallerThan=1000 test",
-			want: &SearchOptions{
+			want: SearchOptions{
 				Conditions:  map[string]bool{"exact": false, "larger": true, "smaller": true},
 				Terms:       []string{"test"},
 				LargerThan:  100,
@@ -56,7 +56,7 @@ func TestParseSearch(t *testing.T) {
 		},
 		{
 			input: "type:audio thisfile",
-			want: &SearchOptions{
+			want: SearchOptions{
 				Conditions: map[string]bool{"exact": false, "audio": true},
 				Terms:      []string{"thisfile"},
 			},
@@ -74,7 +74,7 @@ func TestParseSearch(t *testing.T) {
 }
 
 func TestSearchWhileIndexing(t *testing.T) {
-	InitializeIndex(5, false)
+	InitializeIndex(false)
 	si := GetIndex(rootPath)
 
 	searchTerms := generateRandomSearchTerms(10)
@@ -89,27 +89,29 @@ func TestSearchWhileIndexing(t *testing.T) {
 func TestSearchIndexes(t *testing.T) {
 	index := Index{
 		Directories: map[string]*FileInfo{
-			"/test":      {Files: []ReducedItem{{Name: "audio1.wav", Type: "audio"}}},
-			"/test/path": {Files: []ReducedItem{{Name: "file.txt", Type: "text"}}},
-			"/new/test": {Files: []ReducedItem{
+			"/test":      {Files: []ItemInfo{{Name: "audio1.wav", Type: "audio"}}},
+			"/test/path": {Files: []ItemInfo{{Name: "file.txt", Type: "text"}}},
+			"/new/test": {Files: []ItemInfo{
 				{Name: "audio.wav", Type: "audio"},
 				{Name: "video.mp4", Type: "video"},
 				{Name: "video.MP4", Type: "video"},
 			}},
-			"/new/test/path": {Files: []ReducedItem{{Name: "archive.zip", Type: "archive"}}},
+			"/new/test/path": {Files: []ItemInfo{{Name: "archive.zip", Type: "archive"}}},
 			"/firstDir": {
-				Files: []ReducedItem{
+				Files: []ItemInfo{
 					{Name: "archive.zip", Size: 100, Type: "archive"},
 				},
-				Dirs: map[string]*FileInfo{
-					"thisIsDir": {Name: "thisIsDir", Size: 2 * 1024 * 1024},
+				Folders: []ItemInfo{
+					{Name: "thisIsDir", Type: "directory", Size: 2 * 1024 * 1024},
 				},
 			},
 			"/firstDir/thisIsDir": {
-				Files: []ReducedItem{
+				Files: []ItemInfo{
 					{Name: "hi.txt", Type: "text"},
 				},
-				Size: 2 * 1024 * 1024,
+				ItemInfo: ItemInfo{
+					Size: 2 * 1024 * 1024,
+				},
 			},
 		},
 	}
@@ -117,12 +119,12 @@ func TestSearchIndexes(t *testing.T) {
 	tests := []struct {
 		search         string
 		scope          string
-		expectedResult []searchResult
+		expectedResult []SearchResult
 	}{
 		{
 			search: "audio",
 			scope:  "/new/",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "test/audio.wav",
 					Type: "audio",
@@ -133,7 +135,7 @@ func TestSearchIndexes(t *testing.T) {
 		{
 			search: "test",
 			scope:  "/",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "test/",
 					Type: "directory",
@@ -149,7 +151,7 @@ func TestSearchIndexes(t *testing.T) {
 		{
 			search: "archive",
 			scope:  "/",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "firstDir/archive.zip",
 					Type: "archive",
@@ -165,7 +167,7 @@ func TestSearchIndexes(t *testing.T) {
 		{
 			search: "arch",
 			scope:  "/firstDir",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "archive.zip",
 					Type: "archive",
@@ -176,7 +178,7 @@ func TestSearchIndexes(t *testing.T) {
 		{
 			search: "isdir",
 			scope:  "/",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "firstDir/thisIsDir/",
 					Type: "directory",
@@ -187,7 +189,7 @@ func TestSearchIndexes(t *testing.T) {
 		{
 			search: "IsDir type:largerThan=1",
 			scope:  "/",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "firstDir/thisIsDir/",
 					Type: "directory",
@@ -198,7 +200,7 @@ func TestSearchIndexes(t *testing.T) {
 		{
 			search: "video",
 			scope:  "/",
-			expectedResult: []searchResult{
+			expectedResult: []SearchResult{
 				{
 					Path: "new/test/video.MP4",
 					Type: "video",
@@ -216,7 +218,7 @@ func TestSearchIndexes(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.search, func(t *testing.T) {
 			result := index.Search(tt.search, tt.scope, "")
-			assert.Equal(t, tt.expectedResult, result)
+			assert.ElementsMatch(t, tt.expectedResult, result)
 		})
 	}
 }

backend/files/sync.go

@@ -1,27 +1,23 @@
 package files
 
 import (
-	"log"
 	"path/filepath"
-	"sort"
-	"time"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
 )
 
 // UpdateFileMetadata updates the FileInfo for the specified directory in the index.
 func (si *Index) UpdateMetadata(info *FileInfo) bool {
 	si.mu.Lock()
 	defer si.mu.Unlock()
-	info.CacheTime = time.Now()
 	si.Directories[info.Path] = info
 	return true
 }
 
 // GetMetadataInfo retrieves the FileInfo from the specified directory in the index.
 func (si *Index) GetReducedMetadata(target string, isDir bool) (*FileInfo, bool) {
-	si.mu.RLock()
-	defer si.mu.RUnlock()
+	si.mu.Lock()
+	defer si.mu.Unlock()
 	checkDir := si.makeIndexPath(target)
 	if !isDir {
 		checkDir = si.makeIndexPath(filepath.Dir(target))
@@ -30,50 +26,25 @@ func (si *Index) GetReducedMetadata(target string, isDir bool) (*FileInfo, bool)
 	if !exists {
 		return nil, false
 	}
-	if !isDir {
-		if checkDir == "/" {
-			checkDir = ""
-		}
 
-		baseName := filepath.Base(target)
-		for _, item := range dir.Files {
-			if item.Name == baseName {
-				return &FileInfo{
-					Name:    item.Name,
-					Size:    item.Size,
-					ModTime: item.ModTime,
-					Type:    item.Type,
-					Path:    checkDir + "/" + item.Name,
-				}, true
-			}
+	if isDir {
+		return dir, true
+	}
+	// handle file
+	if checkDir == "/" {
+		checkDir = ""
+	}
+	baseName := filepath.Base(target)
+	for _, item := range dir.Files {
+		if item.Name == baseName {
+			return &FileInfo{
+				Path:     checkDir + "/" + item.Name,
+				ItemInfo: item,
+			}, true
 		}
-		return nil, false
 	}
-	cleanedItems := []ReducedItem{}
-	for name, item := range dir.Dirs {
-		cleanedItems = append(cleanedItems, ReducedItem{
-			Name:    name,
-			Size:    item.Size,
-			ModTime: item.ModTime,
-			Type:    "directory",
-		})
-	}
-	cleanedItems = append(cleanedItems, dir.Files...)
-	sort.Slice(cleanedItems, func(i, j int) bool {
-		return cleanedItems[i].Name < cleanedItems[j].Name
-	})
-	dirname := filepath.Base(dir.Path)
-	if dirname == "." {
-		dirname = "/"
-	}
-	// construct file info
-	return &FileInfo{
-		Name:    dirname,
-		Type:    "directory",
-		Items:   cleanedItems,
-		ModTime: dir.ModTime,
-		Size:    dir.Size,
-	}, true
+	return nil, false
+
 }
 
 // GetMetadataInfo retrieves the FileInfo from the specified directory in the index.
@@ -91,29 +62,10 @@ func (si *Index) GetMetadataInfo(target string, isDir bool) (*FileInfo, bool) {
 func (si *Index) RemoveDirectory(path string) {
 	si.mu.Lock()
 	defer si.mu.Unlock()
+	si.NumDeleted++
 	delete(si.Directories, path)
 }
 
-func (si *Index) UpdateCount(given string) {
-	si.mu.Lock()
-	defer si.mu.Unlock()
-	if given == "files" {
-		si.NumFiles++
-	} else if given == "dirs" {
-		si.NumDirs++
-	} else {
-		log.Println("could not update unknown type: ", given)
-	}
-}
-
-func (si *Index) resetCount() {
-	si.mu.Lock()
-	defer si.mu.Unlock()
-	si.NumDirs = 0
-	si.NumFiles = 0
-	si.inProgress = true
-}
-
 func GetIndex(root string) *Index {
 	for _, index := range indexes {
 		if index.Root == root {
@@ -128,7 +80,6 @@ func GetIndex(root string) *Index {
 		Directories: map[string]*FileInfo{},
 		NumDirs:     0,
 		NumFiles:    0,
-		inProgress:  false,
 	}
 	newIndex.Directories["/"] = &FileInfo{}
 	indexesMutex.Lock()

backend/files/sync_test.go

@@ -34,7 +34,7 @@ func TestGetFileMetadataSize(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			fileInfo, _ := testIndex.GetReducedMetadata(tt.adjustedPath, true)
 			// Iterate over fileInfo.Items to look for expectedName
-			for _, item := range fileInfo.Items {
+			for _, item := range fileInfo.Files {
 				// Assert the existence and the name
 				if item.Name == tt.expectedName {
 					assert.Equal(t, tt.expectedSize, item.Size)
@@ -89,8 +89,8 @@ func TestGetFileMetadata(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			fileInfo, _ := testIndex.GetReducedMetadata(tt.adjustedPath, tt.isDir)
-			if fileInfo == nil {
+			fileInfo, exists := testIndex.GetReducedMetadata(tt.adjustedPath, tt.isDir)
+			if !exists {
 				found := false
 				assert.Equal(t, tt.expectedExists, found)
 				return
@@ -98,7 +98,7 @@ func TestGetFileMetadata(t *testing.T) {
 			found := false
 			if tt.isDir {
 				// Iterate over fileInfo.Items to look for expectedName
-				for _, item := range fileInfo.Items {
+				for _, item := range fileInfo.Files {
 					// Assert the existence and the name
 					if item.Name == tt.expectedName {
 						found = true
@@ -120,9 +120,7 @@ func TestGetFileMetadata(t *testing.T) {
 func TestUpdateFileMetadata(t *testing.T) {
 	info := &FileInfo{
 		Path: "/testpath",
-		Name: "testpath",
-		Type: "directory",
-		Files: []ReducedItem{
+		Files: []ItemInfo{
 			{Name: "testfile.txt"},
 			{Name: "anotherfile.txt"},
 		},
@@ -165,9 +163,11 @@ func TestSetDirectoryInfo(t *testing.T) {
 		Directories: map[string]*FileInfo{
 			"/testpath": {
 				Path: "/testpath",
-				Name: "testpath",
-				Type: "directory",
-				Items: []ReducedItem{
+				ItemInfo: ItemInfo{
+					Name: "testpath",
+					Type: "directory",
+				},
+				Files: []ItemInfo{
 					{Name: "testfile.txt"},
 					{Name: "anotherfile.txt"},
 				},
@@ -176,15 +176,17 @@ func TestSetDirectoryInfo(t *testing.T) {
 	}
 	dir := &FileInfo{
 		Path: "/newPath",
-		Name: "newPath",
-		Type: "directory",
-		Items: []ReducedItem{
+		ItemInfo: ItemInfo{
+			Name: "newPath",
+			Type: "directory",
+		},
+		Files: []ItemInfo{
 			{Name: "testfile.txt"},
 		},
 	}
 	index.UpdateMetadata(dir)
 	storedDir, exists := index.Directories["/newPath"]
-	if !exists || storedDir.Items[0].Name != "testfile.txt" {
+	if !exists || storedDir.Files[0].Name != "testfile.txt" {
 		t.Fatalf("expected SetDirectoryInfo to store directory info correctly")
 	}
 }
@@ -203,56 +205,34 @@ func TestRemoveDirectory(t *testing.T) {
 	}
 }
 
-// Test for UpdateCount
-func TestUpdateCount(t *testing.T) {
-	index := &Index{}
-	index.UpdateCount("files")
-	if index.NumFiles != 1 {
-		t.Fatalf("expected NumFiles to be 1 after UpdateCount('files')")
-	}
-	if index.NumFiles != 1 {
-		t.Fatalf("expected NumFiles to be 1 after UpdateCount('files')")
-	}
-	index.UpdateCount("dirs")
-	if index.NumDirs != 1 {
-		t.Fatalf("expected NumDirs to be 1 after UpdateCount('dirs')")
-	}
-	index.UpdateCount("unknown")
-	// Just ensure it does not panic or update any counters
-	if index.NumFiles != 1 || index.NumDirs != 1 {
-		t.Fatalf("expected counts to remain unchanged for unknown type")
-	}
-	index.resetCount()
-	if index.NumFiles != 0 || index.NumDirs != 0 || !index.inProgress {
-		t.Fatalf("expected resetCount to reset counts and set inProgress to true")
-	}
-}
-
 func init() {
 	testIndex = Index{
-		Root:       "/",
-		NumFiles:   10,
-		NumDirs:    5,
-		inProgress: false,
+		Root:     "/",
+		NumFiles: 10,
+		NumDirs:  5,
 		Directories: map[string]*FileInfo{
 			"/testpath": {
 				Path: "/testpath",
-				Name: "testpath",
-				Type: "directory",
-				Files: []ReducedItem{
+				ItemInfo: ItemInfo{
+					Name: "testpath",
+					Type: "directory",
+				},
+				Files: []ItemInfo{
 					{Name: "testfile.txt", Size: 100},
 					{Name: "anotherfile.txt", Size: 100},
 				},
 			},
 			"/anotherpath": {
 				Path: "/anotherpath",
-				Name: "anotherpath",
-				Type: "directory",
-				Files: []ReducedItem{
+				ItemInfo: ItemInfo{
+					Name: "anotherpath",
+					Type: "directory",
+				},
+				Files: []ItemInfo{
 					{Name: "afile.txt", Size: 100},
 				},
-				Dirs: map[string]*FileInfo{
-					"directory": {Name: "directory", Type: "directory", Size: 100},
+				Folders: []ItemInfo{
+					{Name: "directory", Type: "directory", Size: 100},
 				},
 			},
 		},

backend/go.mod

@@ -1,4 +1,4 @@
-module github.com/gtsteffaniak/filebrowser
+module github.com/gtsteffaniak/filebrowser/backend
 
 go 1.22.5
 
@@ -7,11 +7,10 @@ require (
 	github.com/disintegration/imaging v1.6.2
 	github.com/dsoprea/go-exif/v3 v3.0.1
 	github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568
-	github.com/goccy/go-yaml v1.14.3
+	github.com/gabriel-vasile/mimetype v1.4.7
+	github.com/goccy/go-yaml v1.15.7
 	github.com/golang-jwt/jwt/v4 v4.5.1
 	github.com/google/go-cmp v0.6.0
-	github.com/marusama/semaphore/v2 v2.5.0
-	github.com/mholt/archiver/v3 v3.5.1
 	github.com/shirou/gopsutil/v3 v3.24.5
 	github.com/spf13/afero v1.11.0
 	github.com/spf13/cobra v1.8.1
@@ -19,16 +18,14 @@ require (
 	github.com/stretchr/testify v1.9.0
 	github.com/swaggo/http-swagger v1.3.4
 	github.com/swaggo/swag v1.16.4
-	golang.org/x/crypto v0.29.0
-	golang.org/x/image v0.22.0
-	golang.org/x/text v0.20.0
+	golang.org/x/crypto v0.30.0
+	golang.org/x/image v0.23.0
+	golang.org/x/text v0.21.0
 )
 
 require (
 	github.com/KyleBanks/depth v1.2.1 // indirect
-	github.com/andybalholm/brotli v1.1.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
 	github.com/dsoprea/go-logging v0.0.0-20200710184922-b02d349568dd // indirect
 	github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349 // indirect
 	github.com/go-errors/errors v1.5.1 // indirect
@@ -41,21 +38,15 @@ require (
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
-	github.com/klauspost/compress v1.17.11 // indirect
-	github.com/klauspost/pgzip v1.2.6 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/nwaples/rardecode v1.1.3 // indirect
-	github.com/pierrec/lz4/v4 v4.1.21 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/swaggo/files v1.0.1 // indirect
-	github.com/ulikunitz/xz v0.5.12 // indirect
-	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	go.etcd.io/bbolt v1.3.11 // indirect
-	golang.org/x/net v0.31.0 // indirect
-	golang.org/x/sys v0.27.0 // indirect
-	golang.org/x/tools v0.27.0 // indirect
+	golang.org/x/net v0.32.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/tools v0.28.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

backend/go.sum

@@ -4,9 +4,6 @@ github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc
 github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
 github.com/Sereal/Sereal v0.0.0-20190618215532-0b8ac451a863 h1:BRrxwOZBolJN4gIwvZMJY1tzqBvQgpaZiQRuIDD40jM=
 github.com/Sereal/Sereal v0.0.0-20190618215532-0b8ac451a863/go.mod h1:D0JMgToj/WdxCgd30Kc1UcA9E+WdZoJqeVOuYW7iTBM=
-github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
-github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
-github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 github.com/asdine/storm/v3 v3.2.1 h1:I5AqhkPK6nBZ/qJXySdI7ot5BlXSZ7qvDY1zAn5ZJac=
 github.com/asdine/storm/v3 v3.2.1/go.mod h1:LEpXwGt4pIqrE/XcTvCnZHT5MgZCV6Ub9q7yQzOFWr0=
 github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
@@ -14,9 +11,6 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
 github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
-github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 h1:iFaUwBSo5Svw6L7HYpRu/0lE3e0BaElwnNO1qkNQxBY=
-github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5/go.mod h1:qssHWj60/X5sZFNxpG4HBPDHVqxNm4DfnCKgrbZOT+s=
-github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdfkVLjJ8T6VcRQv3SXugXy999NBtR9aFY=
 github.com/dsoprea/go-exif/v2 v2.0.0-20200321225314-640175a69fe4/go.mod h1:Lm2lMM2zx8p4a34ZemkaUV95AnMl4ZvLbCUbwOvLC2E=
 github.com/dsoprea/go-exif/v3 v3.0.0-20200717053412-08f1b6708903/go.mod h1:0nsO1ce0mh5czxGeLo4+OCZ/C6Eo6ZlMWsz7rH/Gxv8=
 github.com/dsoprea/go-exif/v3 v3.0.0-20210625224831-a6301f85c82b/go.mod h1:cg5SNYKHMmzxsr9X6ZeLh/nfBRHHp5PngtEPcujONtk=
@@ -36,6 +30,8 @@ github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349 h1:DilThiXje
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349/go.mod h1:4GC5sXji84i/p+irqghpPFZBF8tRN/Q7+700G0/DLe8=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
+github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
 github.com/go-errors/errors v1.0.2/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
 github.com/go-errors/errors v1.1.1/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
@@ -53,8 +49,8 @@ github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9Z
 github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk=
 github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
 github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
-github.com/goccy/go-yaml v1.14.3 h1:8tVD+aqqPLWisSEhM+6wWoiURWXCx6BwaTKS6ZeITgM=
-github.com/goccy/go-yaml v1.14.3/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/goccy/go-yaml v1.15.7 h1:L7XuKpd/A66X4w/dlk08lVfiIADdy79a1AzRoIefC98=
+github.com/goccy/go-yaml v1.15.7/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/golang-jwt/jwt/v4 v4.5.1 h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo=
 github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
@@ -67,10 +63,8 @@ github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5y
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -79,14 +73,6 @@ github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJS
 github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
-github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
-github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
-github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
-github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
-github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
-github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -96,16 +82,6 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
-github.com/marusama/semaphore/v2 v2.5.0 h1:o/1QJD9DBYOWRnDhPwDVAXQn6mQYD0gZaS1Tpx6DJGM=
-github.com/marusama/semaphore/v2 v2.5.0/go.mod h1:z9nMiNUekt/LTpTUQdpp+4sJeYqUGpwMHfW0Z8V8fnQ=
-github.com/mholt/archiver/v3 v3.5.1 h1:rDjOBX9JSF5BvoJGvjqK479aL70qh9DIpZCl+k7Clwo=
-github.com/mholt/archiver/v3 v3.5.1/go.mod h1:e3dqJ7H78uzsRSEACH1joayhuSyhnonssnDhppzS1L4=
-github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
-github.com/nwaples/rardecode v1.1.3 h1:cWCaZwfM5H7nAD6PyEdcVnczzV8i/JtotnyW/dD9lEc=
-github.com/nwaples/rardecode v1.1.3/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
-github.com/pierrec/lz4/v4 v4.1.2/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
-github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
@@ -130,16 +106,8 @@ github.com/swaggo/http-swagger v1.3.4 h1:q7t/XLx0n15H1Q9/tk3Y9L4n210XzJF5WtnDX64
 github.com/swaggo/http-swagger v1.3.4/go.mod h1:9dAh0unqMBAlbp1uE2Uc2mQTxNMU/ha4UbucIg1MFkQ=
 github.com/swaggo/swag v1.16.4 h1:clWJtd9LStiG3VeijiCfOVODP6VpHtKdQy9ELFG3s1A=
 github.com/swaggo/swag v1.16.4/go.mod h1:VBsHJRsDvfYvqoiMKnsdwhNV9LEMHgEDZcyVYX0sxPg=
-github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
-github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI=
 github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
-github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
-github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
-github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
-github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
@@ -148,11 +116,11 @@ go.etcd.io/bbolt v1.3.11 h1:yGEzV1wPz2yVCLsD8ZAiGHhHVlczyC9d1rP43/VCRJ0=
 go.etcd.io/bbolt v1.3.11/go.mod h1:dksAq7YMXoljX0xu6VF5DMZGbhYYoLUalEiSySYAS4I=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY=
+golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.22.0 h1:UtK5yLUzilVrkjMAZAZ34DXGpASN8i8pj8g+O+yd10g=
-golang.org/x/image v0.22.0/go.mod h1:9hPFhljd4zZ1GNSIZJ49sqbp45GKK9t6w+iXvGqZUz4=
+golang.org/x/image v0.23.0 h1:HseQ7c2OpPKTPVzNjG5fwJsOTCiiwS4QdsYi5XU6H68=
+golang.org/x/image v0.23.0/go.mod h1:wJJBTdLfCCf3tiHa1fNxpZmUI4mmoZvwMCPP0ddoNKY=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
 golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
@@ -167,12 +135,12 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
-golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI=
+golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
-golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -187,8 +155,8 @@ golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
@@ -197,15 +165,14 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
-golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o=
-golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q=
+golang.org/x/tools v0.28.0 h1:WuB6qZ4RPCQo5aP3WdKZS7i595EdWqWR8vqJTlwTVK8=
+golang.org/x/tools v0.28.0/go.mod h1:dcIOrVd3mfQKTgrDVQHqCPMWy6lnhfhtX3hLXYVLfRw=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
 google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=

backend/http/api.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 func createApiKeyHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {

backend/http/auth.go

@@ -2,9 +2,11 @@ package http
 
 import (
 	"encoding/json"
+	libError "errors"
 	"fmt"
 	"log"
 	"net/http"
+	"net/url"
 	"os"
 	"strings"
 	"sync"
@@ -12,11 +14,13 @@ import (
 
 	"github.com/golang-jwt/jwt/v4"
 	"github.com/golang-jwt/jwt/v4/request"
+	"golang.org/x/crypto/bcrypt"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/share"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 var (
@@ -207,3 +211,29 @@ func makeSignedTokenAPI(user *users.User, name string, duration time.Duration, p
 	}
 	return claim, err
 }
+
+func authenticateShareRequest(r *http.Request, l *share.Link) (int, error) {
+	if l.PasswordHash == "" {
+		return 200, nil
+	}
+
+	if r.URL.Query().Get("token") == l.Token {
+		return 200, nil
+	}
+
+	password := r.Header.Get("X-SHARE-PASSWORD")
+	password, err := url.QueryUnescape(password)
+	if err != nil {
+		return http.StatusUnauthorized, err
+	}
+	if password == "" {
+		return http.StatusUnauthorized, nil
+	}
+	if err := bcrypt.CompareHashAndPassword([]byte(l.PasswordHash), []byte(password)); err != nil {
+		if libError.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
+			return http.StatusUnauthorized, nil
+		}
+		return 401, err
+	}
+	return 200, nil
+}

backend/http/middleware.go

@@ -1,17 +1,20 @@
 package http
 
 import (
+	"compress/gzip"
 	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/golang-jwt/jwt/v4"
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/runner"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/runner"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 type requestContext struct {
@@ -26,6 +29,8 @@ type HttpResponse struct {
 	Token   string `json:"token,omitempty"`
 }
 
+var FileInfoFasterFunc = files.FileInfoFaster
+
 // Updated handleFunc to match the new signature
 type handleFunc func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error)
 
@@ -39,30 +44,30 @@ func withHashFileHelper(fn handleFunc) handleFunc {
 		// Get the file link by hash
 		link, err := store.Share.GetByHash(hash)
 		if err != nil {
-			return http.StatusNotFound, err
+			return http.StatusNotFound, fmt.Errorf("share not found")
 		}
 		// Authenticate the share request if needed
 		var status int
 		if link.Hash != "" {
 			status, err = authenticateShareRequest(r, link)
 			if err != nil || status != http.StatusOK {
-				return status, err
+				return status, fmt.Errorf("could not authenticate share request")
 			}
 		}
 		// Retrieve the user (using the public user by default)
 		user := &users.PublicUser
 
 		// Get file information with options
-		file, err := files.FileInfoFaster(files.FileOptions{
+		file, err := FileInfoFasterFunc(files.FileOptions{
 			Path:       filepath.Join(user.Scope, link.Path+"/"+path),
 			Modify:     user.Perm.Modify,
 			Expand:     true,
 			ReadHeader: config.Server.TypeDetectionByHeader,
 			Checker:    user, // Call your checker function here
-			Token:      link.Token,
 		})
+		file.Token = link.Token
 		if err != nil {
-			return errToStatus(err), err
+			return errToStatus(err), fmt.Errorf("error fetching share from server")
 		}
 
 		// Set the file info in the `data` object
@@ -89,6 +94,15 @@ func withAdminHelper(fn handleFunc) handleFunc {
 // Middleware to retrieve and authenticate user
 func withUserHelper(fn handleFunc) handleFunc {
 	return func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
+		if settings.Config.Auth.Method == "noauth" {
+			var err error
+			// Retrieve the user from the store and store it in the context
+			data.user, err = store.Users.Get(config.Server.Root, "admin")
+			if err != nil {
+				return http.StatusInternalServerError, err
+			}
+			return fn(w, r, data)
+		}
 		keyFunc := func(token *jwt.Token) (interface{}, error) {
 			return config.Auth.Key, nil
 		}
@@ -218,6 +232,7 @@ type ResponseWriterWrapper struct {
 	http.ResponseWriter
 	StatusCode  int
 	wroteHeader bool
+	PayloadSize int
 }
 
 // WriteHeader captures the status code and ensures it's only written once
@@ -240,35 +255,37 @@ func (w *ResponseWriterWrapper) Write(b []byte) (int, error) {
 	return w.ResponseWriter.Write(b)
 }
 
-// LoggingMiddleware logs each request and its status code
+// LoggingMiddleware logs each request and its status code.
 func LoggingMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+
 		start := time.Now()
 
-		// Wrap the ResponseWriter to capture the status code
+		// Wrap the ResponseWriter to capture the status code.
 		wrappedWriter := &ResponseWriterWrapper{ResponseWriter: w, StatusCode: http.StatusOK}
 
-		// Call the next handler
+		// Call the next handler.
 		next.ServeHTTP(wrappedWriter, r)
 
-		// Determine the color based on the status code
+		// Determine the color based on the status code.
 		color := "\033[32m" // Default green color
 		if wrappedWriter.StatusCode >= 300 && wrappedWriter.StatusCode < 500 {
 			color = "\033[33m" // Yellow for client errors (4xx)
 		} else if wrappedWriter.StatusCode >= 500 {
 			color = "\033[31m" // Red for server errors (5xx)
 		}
-		// Capture the full URL path including the query parameters
+
+		// Capture the full URL path including the query parameters.
 		fullURL := r.URL.Path
 		if r.URL.RawQuery != "" {
 			fullURL += "?" + r.URL.RawQuery
 		}
 
-		// Log the request and its status code
+		// Log the request, status code, and response size.
 		log.Printf("%s%-7s | %3d | %-15s | %-12s | \"%s\"%s",
 			color,
 			r.Method,
-			wrappedWriter.StatusCode, // Now capturing the correct status
+			wrappedWriter.StatusCode, // Captured status code
 			r.RemoteAddr,
 			time.Since(start).String(),
 			fullURL,
@@ -277,15 +294,36 @@ func LoggingMiddleware(next http.Handler) http.Handler {
 	})
 }
 
-func renderJSON(w http.ResponseWriter, _ *http.Request, data interface{}) (int, error) {
+func renderJSON(w http.ResponseWriter, r *http.Request, data interface{}) (int, error) {
 	marsh, err := json.Marshal(data)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	if _, err := w.Write(marsh); err != nil {
-		return http.StatusInternalServerError, err
+	// Calculate size in KB
+	payloadSizeKB := len(marsh) / 1024
+	// Check if the client accepts gzip encoding and hasn't explicitly disabled it
+	if acceptsGzip(r) && payloadSizeKB > 10 {
+		// Enable gzip compression
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		w.Header().Set("Content-Encoding", "gzip")
+		gz := gzip.NewWriter(w)
+		defer gz.Close()
+
+		if _, err := gz.Write(marsh); err != nil {
+			return http.StatusInternalServerError, err
+		}
+	} else {
+		// Normal response without compression
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		if _, err := w.Write(marsh); err != nil {
+			return http.StatusInternalServerError, err
+		}
 	}
 
 	return 0, nil
 }
+
+func acceptsGzip(r *http.Request) bool {
+	ae := r.Header.Get("Accept-Encoding")
+	return ae != "" && strings.Contains(ae, "gzip")
+}

backend/http/middleware_test.go

@@ -8,14 +8,15 @@ import (
 	"time"
 
 	"github.com/asdine/storm/v3"
-	"github.com/gtsteffaniak/filebrowser/diskcache"
-	"github.com/gtsteffaniak/filebrowser/img"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/share"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/storage/bolt"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/diskcache"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/img"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/share"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/storage/bolt"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 func setupTestEnv(t *testing.T) {
@@ -37,6 +38,27 @@ func setupTestEnv(t *testing.T) {
 	fileCache = diskcache.NewNoOp() // mocked
 	imgSvc = img.New(1)             // mocked
 	config = &settings.Config       // mocked
+	mockFileInfoFaster(t)           // Mock FileInfoFasterFunc for this test
+}
+
+func mockFileInfoFaster(t *testing.T) {
+	// Backup the original function
+	originalFileInfoFaster := FileInfoFasterFunc
+	// Defer restoration of the original function
+	t.Cleanup(func() { FileInfoFasterFunc = originalFileInfoFaster })
+
+	// Mock the function to skip execution
+	FileInfoFasterFunc = func(opts files.FileOptions) (files.ExtendedFileInfo, error) {
+		return files.ExtendedFileInfo{
+			FileInfo: &files.FileInfo{
+				Path: opts.Path,
+				ItemInfo: files.ItemInfo{
+					Name: "mocked_file",
+					Size: 12345,
+				},
+			},
+		}, nil
+	}
 }
 
 func TestWithAdminHelper(t *testing.T) {
@@ -197,10 +219,7 @@ func TestPublicShareHandlerAuthentication(t *testing.T) {
 			req := newTestRequest(t, tc.share.Hash, tc.token, tc.password, tc.extraHeaders)
 
 			// Serve the request
-			status, err := handler(recorder, req, &requestContext{})
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
+			status, _ := handler(recorder, req, &requestContext{})
 
 			// Check if the response matches the expected status code
 			if status != tc.expectedStatusCode {

backend/http/preview.go

@@ -8,9 +8,10 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/img"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/img"
 )
 
 type ImgService interface {
@@ -49,27 +50,23 @@ func previewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (
 	if path == "" {
 		return http.StatusBadRequest, fmt.Errorf("invalid request path")
 	}
-	file, err := files.FileInfoFaster(files.FileOptions{
+	response, err := files.FileInfoFaster(files.FileOptions{
 		Path:       filepath.Join(d.user.Scope, path),
 		Modify:     d.user.Perm.Modify,
 		Expand:     true,
 		ReadHeader: config.Server.TypeDetectionByHeader,
 		Checker:    d.user,
 	})
+	fileInfo := response.FileInfo
 	if err != nil {
 		return errToStatus(err), err
 	}
-	realPath, _, err := files.GetRealPath(file.Path)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	file.Path = realPath
-	if file.Type == "directory" {
+	if fileInfo.Type == "directory" {
 		return http.StatusBadRequest, fmt.Errorf("can't create preview for directory")
 	}
-	setContentDisposition(w, r, file)
-	if file.Type != "image" {
-		return http.StatusNotImplemented, fmt.Errorf("can't create preview for %s type", file.Type)
+	setContentDisposition(w, r, fileInfo.Name)
+	if !strings.HasPrefix(fileInfo.Type, "image") {
+		return http.StatusNotImplemented, fmt.Errorf("can't create preview for %s type", fileInfo.Type)
 	}
 
 	if (previewSize == "large" && !config.Server.ResizePreview) ||
@@ -77,40 +74,40 @@ func previewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (
 		if !d.user.Perm.Download {
 			return http.StatusAccepted, nil
 		}
-		return rawFileHandler(w, r, file)
+		return rawFileHandler(w, r, fileInfo)
 	}
 
-	format, err := imgSvc.FormatFromExtension(filepath.Ext(file.Name))
+	format, err := imgSvc.FormatFromExtension(filepath.Ext(fileInfo.Name))
 	// Unsupported extensions directly return the raw data
 	if err == img.ErrUnsupportedFormat || format == img.FormatGif {
 		if !d.user.Perm.Download {
 			return http.StatusAccepted, nil
 		}
-		return rawFileHandler(w, r, file)
+		return rawFileHandler(w, r, fileInfo)
 	}
 	if err != nil {
 		return errToStatus(err), err
 	}
-	cacheKey := previewCacheKey(file, previewSize)
+	cacheKey := previewCacheKey(fileInfo, previewSize)
 	resizedImage, ok, err := fileCache.Load(r.Context(), cacheKey)
 	if err != nil {
 		return errToStatus(err), err
 	}
 
 	if !ok {
-		resizedImage, err = createPreview(imgSvc, fileCache, file, previewSize)
+		resizedImage, err = createPreview(imgSvc, fileCache, fileInfo, previewSize)
 		if err != nil {
 			return errToStatus(err), err
 		}
 	}
 	w.Header().Set("Cache-Control", "private")
-	http.ServeContent(w, r, file.Path, file.ModTime, bytes.NewReader(resizedImage))
+	http.ServeContent(w, r, fileInfo.RealPath(), fileInfo.ModTime, bytes.NewReader(resizedImage))
 
 	return 0, nil
 }
 
 func createPreview(imgSvc ImgService, fileCache FileCache, file *files.FileInfo, previewSize string) ([]byte, error) {
-	fd, err := os.Open(file.Path)
+	fd, err := os.Open(file.RealPath())
 	if err != nil {
 		return nil, err
 	}
@@ -154,3 +151,18 @@ func createPreview(imgSvc ImgService, fileCache FileCache, file *files.FileInfo,
 func previewCacheKey(f *files.FileInfo, previewSize string) string {
 	return fmt.Sprintf("%x%x%x", f.RealPath(), f.ModTime.Unix(), previewSize)
 }
+
+func rawFileHandler(w http.ResponseWriter, r *http.Request, file *files.FileInfo) (int, error) {
+	realPath, _, _ := files.GetRealPath(file.Path)
+	fd, err := os.Open(realPath)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	defer fd.Close()
+
+	setContentDisposition(w, r, file.Name)
+
+	w.Header().Set("Cache-Control", "private")
+	http.ServeContent(w, r, file.Name, file.ModTime, fd)
+	return 0, nil
+}

backend/http/public.go

@@ -2,24 +2,19 @@ package http
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 	"strings"
 
-	"golang.org/x/crypto/bcrypt"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/share"
-	"github.com/gtsteffaniak/filebrowser/users"
-
-	_ "github.com/gtsteffaniak/filebrowser/swagger/docs"
+	_ "github.com/gtsteffaniak/filebrowser/backend/swagger/docs"
 )
 
 func publicShareHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	file, ok := d.raw.(*files.FileInfo)
+	file, ok := d.raw.(files.ExtendedFileInfo)
 	if !ok {
 		return http.StatusInternalServerError, fmt.Errorf("failed to assert type *files.FileInfo")
 	}
@@ -38,8 +33,8 @@ func publicUserGetHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 func publicDlHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	file, _ := d.raw.(*files.FileInfo)
-	if file == nil {
+	file, ok := d.raw.(files.ExtendedFileInfo)
+	if !ok {
 		return http.StatusInternalServerError, fmt.Errorf("failed to assert type files.FileInfo")
 	}
 	if d.user == nil {
@@ -47,36 +42,10 @@ func publicDlHandler(w http.ResponseWriter, r *http.Request, d *requestContext)
 	}
 
 	if file.Type == "directory" {
-		return rawDirHandler(w, r, d, file)
+		return rawFilesHandler(w, r, d, []string{file.Path})
 	}
 
-	return rawFileHandler(w, r, file)
-}
-
-func authenticateShareRequest(r *http.Request, l *share.Link) (int, error) {
-	if l.PasswordHash == "" {
-		return 200, nil
-	}
-
-	if r.URL.Query().Get("token") == l.Token {
-		return 200, nil
-	}
-
-	password := r.Header.Get("X-SHARE-PASSWORD")
-	password, err := url.QueryUnescape(password)
-	if err != nil {
-		return http.StatusUnauthorized, err
-	}
-	if password == "" {
-		return http.StatusUnauthorized, nil
-	}
-	if err := bcrypt.CompareHashAndPassword([]byte(l.PasswordHash), []byte(password)); err != nil {
-		if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
-			return http.StatusUnauthorized, nil
-		}
-		return 401, err
-	}
-	return 200, nil
+	return rawFileHandler(w, r, file.FileInfo)
 }
 
 // health godoc

backend/http/raw.go

@@ -1,79 +1,28 @@
 package http
 
 import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
 	"errors"
+	"fmt"
+	"io"
 	"log"
 	"net/http"
 	"net/url"
 	"os"
-	gopath "path"
 	"path/filepath"
 	"strings"
 
-	"github.com/mholt/archiver/v3"
-
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/fileutils"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
 )
 
-func slashClean(name string) string {
-	if name == "" || name[0] != '/' {
-		name = "/" + name
-	}
-	return gopath.Clean(name)
-}
-
-func parseQueryFiles(r *http.Request, f *files.FileInfo, _ *users.User) ([]string, error) {
-	var fileSlice []string
-	names := strings.Split(r.URL.Query().Get("files"), ",")
-
-	if len(names) == 0 {
-		fileSlice = append(fileSlice, f.Path)
-	} else {
-		for _, name := range names {
-			name, err := url.QueryUnescape(strings.Replace(name, "+", "%2B", -1)) //nolint:govet
-			if err != nil {
-				return nil, err
-			}
-
-			name = slashClean(name)
-			fileSlice = append(fileSlice, filepath.Join(f.Path, name))
-		}
-	}
-
-	return fileSlice, nil
-}
-
-// nolint: goconst,nolintlint
-func parseQueryAlgorithm(r *http.Request) (string, archiver.Writer, error) {
-	// TODO: use enum
-	switch r.URL.Query().Get("algo") {
-	case "zip", "true", "":
-		return ".zip", archiver.NewZip(), nil
-	case "tar":
-		return ".tar", archiver.NewTar(), nil
-	case "targz":
-		return ".tar.gz", archiver.NewTarGz(), nil
-	case "tarbz2":
-		return ".tar.bz2", archiver.NewTarBz2(), nil
-	case "tarxz":
-		return ".tar.xz", archiver.NewTarXz(), nil
-	case "tarlz4":
-		return ".tar.lz4", archiver.NewTarLz4(), nil
-	case "tarsz":
-		return ".tar.sz", archiver.NewTarSz(), nil
-	default:
-		return "", nil, errors.New("format not implemented")
-	}
-}
-
-func setContentDisposition(w http.ResponseWriter, r *http.Request, file *files.FileInfo) {
+func setContentDisposition(w http.ResponseWriter, r *http.Request, fileName string) {
 	if r.URL.Query().Get("inline") == "true" {
 		w.Header().Set("Content-Disposition", "inline")
 	} else {
 		// As per RFC6266 section 4.3
-		w.Header().Set("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(file.Name))
+		w.Header().Set("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(fileName))
 	}
 }
 
@@ -83,146 +32,201 @@ func setContentDisposition(w http.ResponseWriter, r *http.Request, file *files.F
 // @Tags Resources
 // @Accept json
 // @Produce json
-// @Param path query string true "Path to the file or directory"
-// @Param files query string false "Comma-separated list of specific files within the directory (optional)"
+// @Param files query string true "Comma-separated list of specific files within the directory (required)"
 // @Param inline query bool false "If true, sets 'Content-Disposition' to 'inline'. Otherwise, defaults to 'attachment'."
-// @Param algo query string false "Compression algorithm for archiving multiple files or directories. Options: 'zip', 'tar', 'targz', 'tarbz2', 'tarxz', 'tarlz4', 'tarsz'. Default is 'zip'."
+// @Param algo query string false "Compression algorithm for archiving multiple files or directories. Options: 'zip' and 'tar.gz'. Default is 'zip'."
 // @Success 200 {file} file "Raw file or directory content, or archive for multiple files"
 // @Failure 202 {object} map[string]string "Download permissions required"
 // @Failure 400 {object} map[string]string "Invalid request path"
 // @Failure 404 {object} map[string]string "File or directory not found"
-// @Failure 415 {object} map[string]string "Unsupported file type for preview"
 // @Failure 500 {object} map[string]string "Internal server error"
 // @Router /api/raw [get]
 func rawHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	if !d.user.Perm.Download {
 		return http.StatusAccepted, nil
 	}
-	path := r.URL.Query().Get("path")
-	file, err := files.FileInfoFaster(files.FileOptions{
-		Path:       filepath.Join(d.user.Scope, path),
-		Modify:     d.user.Perm.Modify,
-		Expand:     false,
-		ReadHeader: config.Server.TypeDetectionByHeader,
-		Checker:    d.user,
-	})
+	encodedFiles := r.URL.Query().Get("files")
+	// Decode the URL-encoded path
+	files, err := url.QueryUnescape(encodedFiles)
 	if err != nil {
-		return errToStatus(err), err
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
-	if files.IsNamedPipe(file.Mode) {
-		setContentDisposition(w, r, file)
-		return 0, nil
-	}
-	if file.Type == "directory" {
-		return rawDirHandler(w, r, d, file)
-	}
-
-	return rawFileHandler(w, r, file)
+	return rawFilesHandler(w, r, d, strings.Split(files, ","))
 }
 
-func addFile(ar archiver.Writer, d *requestContext, path, commonPath string) error {
-	if !d.user.Check(path) {
+func addFile(path string, d *requestContext, tarWriter *tar.Writer, zipWriter *zip.Writer) error {
+	realPath, _, _ := files.GetRealPath(d.user.Scope, path)
+	if !d.user.Check(realPath) {
 		return nil
 	}
-	info, err := os.Stat(path)
+	info, err := os.Stat(realPath)
 	if err != nil {
 		return err
 	}
 
-	if !info.IsDir() && !info.Mode().IsRegular() {
-		return nil
+	if info.IsDir() {
+		// Walk through directory contents
+		return filepath.Walk(realPath, func(filePath string, fileInfo os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			relPath, err := filepath.Rel(filepath.Dir(realPath), filePath) // Relative path including base dir
+			if err != nil {
+				return err
+			}
+			if fileInfo.IsDir() {
+				if tarWriter != nil {
+					header := &tar.Header{
+						Name:     relPath + "/",
+						Mode:     0755,
+						Typeflag: tar.TypeDir,
+						ModTime:  fileInfo.ModTime(),
+					}
+					return tarWriter.WriteHeader(header)
+				}
+				if zipWriter != nil {
+					_, err := zipWriter.Create(relPath + "/")
+					return err
+				}
+				return nil
+			}
+			return addSingleFile(filePath, relPath, zipWriter, tarWriter)
+		})
 	}
 
-	file, err := os.Open(path)
+	// Add a single file if it's not a directory
+	return addSingleFile(realPath, filepath.Base(realPath), zipWriter, tarWriter)
+}
+
+func addSingleFile(realPath, archivePath string, zipWriter *zip.Writer, tarWriter *tar.Writer) error {
+	file, err := os.Open(realPath)
 	if err != nil {
 		return err
 	}
 	defer file.Close()
 
-	if path != commonPath {
-		filename := strings.TrimPrefix(path, commonPath)
-		filename = strings.TrimPrefix(filename, string(filepath.Separator))
-		err = ar.Write(archiver.File{
-			FileInfo: archiver.FileInfo{
-				FileInfo:   info,
-				CustomName: filename,
-			},
-			ReadCloser: file,
-		})
-		if err != nil {
-			return err
-		}
+	info, err := os.Stat(realPath)
+	if err != nil {
+		return err
 	}
 
-	if info.IsDir() {
-		names, err := file.Readdirnames(0)
+	if tarWriter != nil {
+		header, err := tar.FileInfoHeader(info, realPath)
 		if err != nil {
 			return err
 		}
+		header.Name = archivePath
+		if err = tarWriter.WriteHeader(header); err != nil {
+			return err
+		}
+		_, err = io.Copy(tarWriter, file)
+		return err
+	}
 
-		for _, name := range names {
-			fPath := filepath.Join(path, name)
-			err = addFile(ar, d, fPath, commonPath)
-			if err != nil {
-				log.Printf("Failed to archive %s: %v", fPath, err)
-			}
+	if zipWriter != nil {
+		header, err := zip.FileInfoHeader(info)
+		if err != nil {
+			return err
+		}
+		header.Name = archivePath
+		writer, err := zipWriter.CreateHeader(header)
+		if err != nil {
+			return err
+		}
+		_, err = io.Copy(writer, file)
+		return err
+	}
+
+	return nil
+}
+
+func rawFilesHandler(w http.ResponseWriter, r *http.Request, d *requestContext, fileList []string) (int, error) {
+	filePath := fileList[0]
+	fileName := filepath.Base(filePath)
+	realPath, isDir, err := files.GetRealPath(d.user.Scope, filePath)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	if len(fileList) == 1 && !isDir {
+		fd, err2 := os.Open(realPath)
+		if err2 != nil {
+			return http.StatusInternalServerError, err
+		}
+		defer fd.Close()
+
+		// Get file information
+		fileInfo, err3 := fd.Stat()
+		if err3 != nil {
+			return http.StatusInternalServerError, err
+		}
+
+		// Set headers and serve the file
+		setContentDisposition(w, r, fileName)
+		w.Header().Set("Cache-Control", "private")
+
+		// Serve the content
+		http.ServeContent(w, r, fileName, fileInfo.ModTime(), fd)
+		return 0, nil
+	}
+
+	algo := r.URL.Query().Get("algo")
+	var extension string
+	switch algo {
+	case "zip", "true", "":
+		extension = ".zip"
+	case "tar.gz":
+		extension = ".tar.gz"
+	default:
+		return http.StatusInternalServerError, errors.New("format not implemented")
+	}
+
+	baseDirName := filepath.Base(filepath.Dir(realPath))
+	if baseDirName == "" || baseDirName == "/" {
+		baseDirName = "download"
+	}
+	downloadFileName := url.PathEscape(baseDirName + "." + algo)
+	w.Header().Set("Content-Disposition", "attachment; filename*=utf-8''"+downloadFileName)
+	// Create the archive and stream it directly to the response
+	if extension == ".zip" {
+		err = createZip(w, d, fileList...)
+	} else {
+		err = createTarGz(w, d, fileList...)
+	}
+
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	return 0, nil
+}
+
+func createZip(w io.Writer, d *requestContext, filenames ...string) error {
+	zipWriter := zip.NewWriter(w)
+	defer zipWriter.Close()
+
+	for _, fname := range filenames {
+		err := addFile(fname, d, nil, zipWriter)
+		if err != nil {
+			log.Printf("Failed to add %s to ZIP: %v", fname, err)
 		}
 	}
 
 	return nil
 }
 
-func rawDirHandler(w http.ResponseWriter, r *http.Request, d *requestContext, file *files.FileInfo) (int, error) {
-	filenames, err := parseQueryFiles(r, file, d.user)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	extension, ar, err := parseQueryAlgorithm(r)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
+func createTarGz(w io.Writer, d *requestContext, filenames ...string) error {
+	gzWriter := gzip.NewWriter(w)
+	defer gzWriter.Close()
 
-	err = ar.Create(w)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	defer ar.Close()
-
-	commonDir := fileutils.CommonPrefix(filepath.Separator, filenames...)
-
-	name := filepath.Base(commonDir)
-	if name == "." || name == "" || name == string(filepath.Separator) {
-		name = file.Name
-	}
-	// Prefix used to distinguish a filelist generated
-	// archive from the full directory archive
-	if len(filenames) > 1 {
-		name = "_" + name
-	}
-	name += extension
-	w.Header().Set("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(name))
+	tarWriter := tar.NewWriter(gzWriter)
+	defer tarWriter.Close()
 
 	for _, fname := range filenames {
-		err = addFile(ar, d, fname, commonDir)
+		err := addFile(fname, d, tarWriter, nil)
 		if err != nil {
-			log.Printf("Failed to archive %s: %v", fname, err)
+			log.Printf("Failed to add %s to TAR.GZ: %v", fname, err)
 		}
 	}
 
-	return 0, nil
-}
-
-func rawFileHandler(w http.ResponseWriter, r *http.Request, file *files.FileInfo) (int, error) {
-	realPath, _, _ := files.GetRealPath(file.Path)
-	fd, err := os.Open(realPath)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	defer fd.Close()
-
-	setContentDisposition(w, r, file)
-
-	w.Header().Set("Cache-Control", "private")
-	http.ServeContent(w, r, file.Name, file.ModTime, fd)
-	return 0, nil
+	return nil
 }

backend/http/resource.go

@@ -8,12 +8,14 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/shirou/gopsutil/v3/disk"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/files"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 // resourceGetHandler retrieves information about a resource.
@@ -32,8 +34,13 @@ import (
 // @Router /api/resources [get]
 func resourceGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	// TODO source := r.URL.Query().Get("source")
-	path := r.URL.Query().Get("path")
-	file, err := files.FileInfoFaster(files.FileOptions{
+	encodedPath := r.URL.Query().Get("path")
+	// Decode the URL-encoded path
+	path, err := url.QueryUnescape(encodedPath)
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
+	}
+	fileInfo, err := files.FileInfoFaster(files.FileOptions{
 		Path:       filepath.Join(d.user.Scope, path),
 		Modify:     d.user.Perm.Modify,
 		Expand:     true,
@@ -44,18 +51,19 @@ func resourceGetHandler(w http.ResponseWriter, r *http.Request, d *requestContex
 	if err != nil {
 		return errToStatus(err), err
 	}
-	if file.Type == "directory" {
-		return renderJSON(w, r, file)
+	if fileInfo.Type == "directory" {
+		return renderJSON(w, r, fileInfo)
 	}
-	if checksum := r.URL.Query().Get("checksum"); checksum != "" {
-		err := file.Checksum(checksum)
+	if algo := r.URL.Query().Get("checksum"); algo != "" {
+		checksums, err := files.GetChecksum(fileInfo.Path, algo)
 		if err == errors.ErrInvalidOption {
 			return http.StatusBadRequest, nil
 		} else if err != nil {
 			return http.StatusInternalServerError, err
 		}
+		fileInfo.Checksums = checksums
 	}
-	return renderJSON(w, r, file)
+	return renderJSON(w, r, fileInfo)
 
 }
 
@@ -74,7 +82,12 @@ func resourceGetHandler(w http.ResponseWriter, r *http.Request, d *requestContex
 // @Router /api/resources [delete]
 func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	// TODO source := r.URL.Query().Get("source")
-	path := r.URL.Query().Get("path")
+	encodedPath := r.URL.Query().Get("path")
+	// Decode the URL-encoded path
+	path, err := url.QueryUnescape(encodedPath)
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
+	}
 	if path == "/" || !d.user.Perm.Delete {
 		return http.StatusForbidden, nil
 	}
@@ -83,20 +96,20 @@ func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestCon
 		return http.StatusNotFound, err
 	}
 	fileOpts := files.FileOptions{
-		Path:       filepath.Join(d.user.Scope, path),
+		Path:       realPath,
 		IsDir:      isDir,
 		Modify:     d.user.Perm.Modify,
 		Expand:     false,
 		ReadHeader: config.Server.TypeDetectionByHeader,
 		Checker:    d.user,
 	}
-	file, err := files.FileInfoFaster(fileOpts)
+	fileInfo, err := files.FileInfoFaster(fileOpts)
 	if err != nil {
 		return errToStatus(err), err
 	}
 
 	// delete thumbnails
-	err = delThumbs(r.Context(), fileCache, file)
+	err = delThumbs(r.Context(), fileCache, fileInfo.FileInfo)
 	if err != nil {
 		return errToStatus(err), err
 	}
@@ -126,26 +139,30 @@ func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestCon
 // @Router /api/resources [post]
 func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	// TODO source := r.URL.Query().Get("source")
-	path := r.URL.Query().Get("path")
+	encodedPath := r.URL.Query().Get("path")
+	// Decode the URL-encoded path
+	path, err := url.QueryUnescape(encodedPath)
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
+	}
 	if !d.user.Perm.Create || !d.user.Check(path) {
 		return http.StatusForbidden, nil
 	}
 	fileOpts := files.FileOptions{
-		Path:       filepath.Join(d.user.Scope, path),
-		Modify:     d.user.Perm.Modify,
-		Expand:     false,
-		ReadHeader: config.Server.TypeDetectionByHeader,
-		Checker:    d.user,
+		Path:    filepath.Join(d.user.Scope, path),
+		Modify:  d.user.Perm.Modify,
+		Expand:  false,
+		Checker: d.user,
 	}
 	// Directories creation on POST.
 	if strings.HasSuffix(path, "/") {
-		err := files.WriteDirectory(fileOpts)
+		err = files.WriteDirectory(fileOpts)
 		if err != nil {
 			return errToStatus(err), err
 		}
 		return http.StatusOK, nil
 	}
-	file, err := files.FileInfoFaster(fileOpts)
+	fileInfo, err := files.FileInfoFaster(fileOpts)
 	if err == nil {
 		if r.URL.Query().Get("override") != "true" {
 			return http.StatusConflict, nil
@@ -156,13 +173,17 @@ func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 			return http.StatusForbidden, nil
 		}
 
-		err = delThumbs(r.Context(), fileCache, file)
+		err = delThumbs(r.Context(), fileCache, fileInfo.FileInfo)
 		if err != nil {
 			return errToStatus(err), err
 		}
 	}
 	err = files.WriteFile(fileOpts, r.Body)
-	return errToStatus(err), err
+	if err != nil {
+		return errToStatus(err), err
+
+	}
+	return http.StatusOK, nil
 }
 
 // resourcePutHandler updates an existing file resource.
@@ -181,7 +202,13 @@ func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 // @Router /api/resources [put]
 func resourcePutHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	// TODO source := r.URL.Query().Get("source")
-	path := r.URL.Query().Get("path")
+	// TODO source := r.URL.Query().Get("source")
+	encodedPath := r.URL.Query().Get("path")
+	// Decode the URL-encoded path
+	path, err := url.QueryUnescape(encodedPath)
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
+	}
 	if !d.user.Perm.Modify || !d.user.Check(path) {
 		return http.StatusForbidden, nil
 	}
@@ -226,16 +253,21 @@ func resourcePutHandler(w http.ResponseWriter, r *http.Request, d *requestContex
 // @Router /api/resources [patch]
 func resourcePatchHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	// TODO source := r.URL.Query().Get("source")
-	src := r.URL.Query().Get("from")
-	dst := r.URL.Query().Get("destination")
 	action := r.URL.Query().Get("action")
-	dst, err := url.QueryUnescape(dst)
-	if !d.user.Check(src) || !d.user.Check(dst) {
-		return http.StatusForbidden, nil
+	encodedFrom := r.URL.Query().Get("from")
+	// Decode the URL-encoded path
+	src, err := url.QueryUnescape(encodedFrom)
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
+	dst := r.URL.Query().Get("destination")
+	dst, err = url.QueryUnescape(dst)
 	if err != nil {
 		return errToStatus(err), err
 	}
+	if !d.user.Check(src) || !d.user.Check(dst) {
+		return http.StatusForbidden, nil
+	}
 	if dst == "/" || src == "/" {
 		return http.StatusForbidden, nil
 	}
@@ -291,17 +323,18 @@ func delThumbs(ctx context.Context, fileCache FileCache, file *files.FileInfo) e
 
 func patchAction(ctx context.Context, action, src, dst string, d *requestContext, fileCache FileCache, isSrcDir bool) error {
 	switch action {
-	// TODO: use enum
 	case "copy":
 		if !d.user.Perm.Create {
 			return errors.ErrPermissionDenied
 		}
-		return files.CopyResource(src, dst, isSrcDir)
+		err := files.CopyResource(src, dst, isSrcDir)
+		return err
 	case "rename", "move":
+
 		if !d.user.Perm.Rename {
 			return errors.ErrPermissionDenied
 		}
-		file, err := files.FileInfoFaster(files.FileOptions{
+		fileInfo, err := files.FileInfoFaster(files.FileOptions{
 			Path:       src,
 			IsDir:      isSrcDir,
 			Modify:     d.user.Perm.Modify,
@@ -314,7 +347,7 @@ func patchAction(ctx context.Context, action, src, dst string, d *requestContext
 		}
 
 		// delete thumbnails
-		err = delThumbs(ctx, fileCache, file)
+		err = delThumbs(ctx, fileCache, fileInfo.FileInfo)
 		if err != nil {
 			return err
 		}
@@ -345,31 +378,49 @@ func diskUsage(w http.ResponseWriter, r *http.Request, d *requestContext) (int,
 	if source == "" {
 		source = "/"
 	}
-	file, err := files.FileInfoFaster(files.FileOptions{
-		Path:    source,
-		Checker: d.user,
-	})
+
+	value, ok := utils.DiskUsageCache.Get(source).(DiskUsageResponse)
+	if ok {
+		return renderJSON(w, r, &value)
+	}
+
+	fPath, isDir, err := files.GetRealPath(d.user.Scope, source)
 	if err != nil {
 		return errToStatus(err), err
 	}
-	fPath := file.RealPath()
-	if file.Type != "directory" {
-		return http.StatusBadRequest, fmt.Errorf("path is not a directory")
+	if !isDir {
+		return http.StatusNotFound, fmt.Errorf("not a directory: %s", source)
 	}
 	usage, err := disk.UsageWithContext(r.Context(), fPath)
 	if err != nil {
 		return errToStatus(err), err
 	}
-	return renderJSON(w, r, &DiskUsageResponse{
+	latestUsage := DiskUsageResponse{
 		Total: usage.Total,
 		Used:  usage.Used,
-	})
+	}
+	utils.DiskUsageCache.Set(source, latestUsage)
+	return renderJSON(w, r, &latestUsage)
 }
 
 func inspectIndex(w http.ResponseWriter, r *http.Request) {
-	path := r.URL.Query().Get("path")
+	encodedPath := r.URL.Query().Get("path")
+	// Decode the URL-encoded path
+	path, _ := url.QueryUnescape(encodedPath)
 	isDir := r.URL.Query().Get("isDir") == "true"
 	index := files.GetIndex(config.Server.Root)
 	info, _ := index.GetReducedMetadata(path, isDir)
 	renderJSON(w, r, info) // nolint:errcheck
 }
+
+func mockData(w http.ResponseWriter, r *http.Request) {
+	d := r.URL.Query().Get("numDirs")
+	f := r.URL.Query().Get("numFiles")
+	NumDirs, err := strconv.Atoi(d)
+	numFiles, err2 := strconv.Atoi(f)
+	if err != nil || err2 != nil {
+		return
+	}
+	mockDir := files.CreateMockData(NumDirs, numFiles)
+	renderJSON(w, r, mockDir) // nolint:errcheck
+}

backend/http/router.go

@@ -10,9 +10,9 @@ import (
 	"os"
 	"text/template"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/version"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/version"
 
 	httpSwagger "github.com/swaggo/http-swagger" // http-swagger middleware
 )
@@ -96,6 +96,7 @@ func StartHttp(Service ImgService, storage *storage.Storage, cache FileCache) {
 	api.HandleFunc("GET /preview", withUser(previewHandler))
 	if version.Version == "testing" || version.Version == "untracked" {
 		api.HandleFunc("GET /inspectIndex", inspectIndex)
+		api.HandleFunc("GET /mockData", mockData)
 	}
 
 	// Share routes
@@ -122,7 +123,7 @@ func StartHttp(Service ImgService, storage *storage.Storage, cache FileCache) {
 	router.HandleFunc(config.Server.BaseURL, indexHandler)
 
 	// health
-	router.HandleFunc(fmt.Sprintf("GET %vhealth/", config.Server.BaseURL), healthHandler)
+	router.HandleFunc(fmt.Sprintf("GET %vhealth", config.Server.BaseURL), healthHandler)
 
 	// Swagger
 	router.Handle(fmt.Sprintf("%vswagger/", config.Server.BaseURL),
@@ -172,7 +173,7 @@ func StartHttp(Service ImgService, storage *storage.Storage, cache FileCache) {
 	} else {
 		// Set HTTP scheme and the default port for HTTP
 		scheme = "http"
-		if config.Server.Port != 443 {
+		if config.Server.Port != 80 {
 			port = fmt.Sprintf(":%d", config.Server.Port)
 		}
 		// Build the full URL with host and port

backend/http/search.go

@@ -4,8 +4,8 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
 )
 
 // searchHandler handles search requests for files based on the provided query.
@@ -49,7 +49,7 @@ import (
 // @Param query query string true "Search query"
 // @Param scope query string false "path within user scope to search, for example '/first/second' to search within the second directory only"
 // @Param SessionId header string false "User session ID, add unique value to prevent collisions"
-// @Success 200 {array} files.searchResult "List of search results"
+// @Success 200 {array} files.SearchResult "List of search results"
 // @Failure 400 {object} map[string]string "Bad Request"
 // @Router /api/search [get]
 func searchHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {

backend/http/settings.go

@@ -4,8 +4,8 @@ import (
 	"encoding/json"
 	"net/http"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 type settingsData struct {

backend/http/share.go

@@ -12,8 +12,8 @@ import (
 
 	"golang.org/x/crypto/bcrypt"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/share"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/share"
 )
 
 // shareListHandler returns a list of all share links.
@@ -69,7 +69,7 @@ func shareGetsHandler(w http.ResponseWriter, r *http.Request, d *requestContext)
 		return renderJSON(w, r, []*share.Link{})
 	}
 	if err != nil {
-		return http.StatusInternalServerError, err
+		return http.StatusInternalServerError, fmt.Errorf("error getting share info from server")
 	}
 	return renderJSON(w, r, s)
 }
@@ -188,7 +188,7 @@ func getSharePasswordHash(body share.CreateBody) (data []byte, statuscode int, e
 
 	hash, err := bcrypt.GenerateFromPassword([]byte(body.Password), bcrypt.DefaultCost)
 	if err != nil {
-		return nil, http.StatusInternalServerError, fmt.Errorf("failed to hash password: %w", err)
+		return nil, http.StatusInternalServerError, fmt.Errorf("failed to hash password")
 	}
 
 	return hash, 0, nil

backend/http/static.go

@@ -12,9 +12,9 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/version"
+	"github.com/gtsteffaniak/filebrowser/backend/auth"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/version"
 )
 
 var templateRenderer *TemplateRenderer

backend/http/users.go

@@ -2,6 +2,7 @@ package http
 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
 	"reflect"
@@ -11,10 +12,10 @@ import (
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/storage"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 var (
@@ -118,8 +119,16 @@ func userDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext
 	num, _ := strconv.ParseUint(givenUserIdString, 10, 32)
 	givenUserId := uint(num)
 
-	if givenUserId == d.user.ID || !d.user.Perm.Admin {
-		return http.StatusForbidden, nil
+	if givenUserId == d.user.ID {
+		return http.StatusForbidden, fmt.Errorf("cannot delete your own user")
+	}
+
+	if !d.user.Perm.Admin {
+		return http.StatusForbidden, fmt.Errorf("cannot delete users without admin permissions")
+	}
+
+	if givenUserId == 1 {
+		return http.StatusForbidden, fmt.Errorf("cannot delete the default admin user")
 	}
 
 	// Delete the user

backend/http/utils.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"os"
 
-	libErrors "github.com/gtsteffaniak/filebrowser/errors"
+	libErrors "github.com/gtsteffaniak/filebrowser/backend/errors"
 )
 
 func errToStatus(err error) int {

backend/img/service.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/disintegration/imaging"
 	"github.com/dsoprea/go-exif/v3"
-	"github.com/marusama/semaphore/v2"
 
 	exifcommon "github.com/dsoprea/go-exif/v3/common"
 )
@@ -21,12 +20,32 @@ var ErrUnsupportedFormat = errors.New("unsupported image format")
 
 // Service
 type Service struct {
-	sem semaphore.Semaphore
+	sem chan struct{}
 }
 
+// New initializes the service with a specified number of workers (concurrency limit).
 func New(workers int) *Service {
 	return &Service{
-		sem: semaphore.New(workers),
+		sem: make(chan struct{}, workers), // Buffered channel to limit concurrency.
+	}
+}
+
+// acquire blocks until a worker is available or the context is canceled.
+func (s *Service) acquire(ctx context.Context) error {
+	select {
+	case s.sem <- struct{}{}: // Reserve a worker.
+		return nil
+	case <-ctx.Done(): // Context canceled or deadline exceeded.
+		return ctx.Err()
+	}
+}
+
+// release frees up a worker slot.
+func (s *Service) release() {
+	select {
+	case <-s.sem: // Free a worker slot.
+	default:
+		// Shouldn't happen, but guard against releasing more than acquired.
 	}
 }
 
@@ -136,10 +155,10 @@ func WithQuality(quality Quality) Option {
 }
 
 func (s *Service) Resize(ctx context.Context, in io.Reader, width, height int, out io.Writer, options ...Option) error {
-	if err := s.sem.Acquire(ctx, 1); err != nil {
+	if err := s.acquire(ctx); err != nil {
 		return err
 	}
-	defer s.sem.Release(1)
+	defer s.release()
 
 	format, wrappedReader, err := s.detectFormat(in)
 	if err != nil {
@@ -242,3 +261,22 @@ func getEmbeddedThumbnail(in io.Reader) ([]byte, io.Reader, error) {
 	thm, err := ifd.Thumbnail()
 	return thm, wrappedReader, err
 }
+
+// CreateThumbnail takes raw image data and creates a thumbnail image.
+func CreateThumbnail(rawData io.Reader, width, height int) (image.Image, error) {
+	// Decode the raw image to get an image.Image.
+	img, _, err := image.Decode(rawData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode image: %w", err)
+	}
+
+	// Resize the image to create a thumbnail using the specified dimensions.
+	thumb := imaging.Fit(img, width, height, imaging.Lanczos)
+
+	// Optionally, convert the thumbnail to grayscale if needed.
+	// Uncomment the line below if you want the result to be grayscale.
+	// thumb = imaging.Grayscale(thumb)
+
+	// Return the resized thumbnail image.
+	return thumb, nil
+}

backend/main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/gtsteffaniak/filebrowser/cmd"
+	"github.com/gtsteffaniak/filebrowser/backend/cmd"
 )
 
 func main() {

backend/runner/parser.go

@@ -3,7 +3,7 @@ package runner
 import (
 	"os/exec"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
 )
 
 // ParseCommand parses the command taking in account if the current

backend/runner/runner.go

@@ -7,9 +7,9 @@ import (
 	"os/exec"
 	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // Runner is a commands runner.

backend/settings/config.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 
 	"github.com/goccy/go-yaml"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 var Config Settings
@@ -66,7 +66,6 @@ func setDefaults() Settings {
 			EnableThumbnails:   true,
 			ResizePreview:      false,
 			EnableExec:         false,
-			IndexingInterval:   5,
 			Port:               80,
 			NumImageProcessors: 4,
 			BaseURL:            "",

backend/settings/dir_test.go

@@ -3,7 +3,7 @@ package settings
 import (
 	"testing"
 
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 func TestSettings_MakeUserDir(t *testing.T) {

backend/settings/settings.go

@@ -3,7 +3,7 @@ package settings
 import (
 	"crypto/rand"
 
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 const DefaultUsersHomeBasePath = "/users"

backend/settings/storage.go

@@ -1,8 +1,8 @@
 package settings
 
 import (
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // StorageBackend is a settings storage backend.

backend/settings/structs.go

@@ -1,7 +1,7 @@
 package settings
 
 import (
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 type Settings struct {

backend/share/storage.go

@@ -3,7 +3,7 @@ package share
 import (
 	"time"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
 )
 
 // StorageBackend is the interface to implement for a share storage.

backend/storage/bolt/auth.go

@@ -2,8 +2,8 @@ package bolt
 
 import (
 	"github.com/asdine/storm/v3"
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/auth"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
 )
 
 type authBackend struct {

backend/storage/bolt/bolt.go

@@ -3,10 +3,10 @@ package bolt
 import (
 	"github.com/asdine/storm/v3"
 
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/share"
-	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/backend/auth"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/share"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
 )
 
 // NewStorage creates a storage.Storage based on Bolt DB.

backend/storage/bolt/config.go

@@ -2,7 +2,7 @@ package bolt
 
 import (
 	"github.com/asdine/storm/v3"
-	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
 )
 
 type settingsBackend struct {

backend/storage/bolt/share.go

@@ -4,8 +4,8 @@ import (
 	"github.com/asdine/storm/v3"
 	"github.com/asdine/storm/v3/q"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/share"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/share"
 )
 
 type shareBackend struct {

backend/storage/bolt/users.go

@@ -6,9 +6,9 @@ import (
 
 	"github.com/asdine/storm/v3"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 type usersBackend struct {

backend/storage/bolt/utils.go

@@ -3,7 +3,7 @@ package bolt
 import (
 	"github.com/asdine/storm/v3"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
 )
 
 func get(db *storm.DB, name string, to interface{}) error {

backend/storage/storage.go

@@ -7,14 +7,14 @@ import (
 	"path/filepath"
 
 	"github.com/asdine/storm/v3"
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/share"
-	"github.com/gtsteffaniak/filebrowser/storage/bolt"
-	"github.com/gtsteffaniak/filebrowser/users"
-	"github.com/gtsteffaniak/filebrowser/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/auth"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/files"
+	"github.com/gtsteffaniak/filebrowser/backend/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/share"
+	"github.com/gtsteffaniak/filebrowser/backend/storage/bolt"
+	"github.com/gtsteffaniak/filebrowser/backend/users"
+	"github.com/gtsteffaniak/filebrowser/backend/utils"
 )
 
 // Storage is a storage powered by a Backend which makes the necessary

backend/swagger/docs/docs.go

@@ -114,17 +114,11 @@ const docTemplate = `{
                 "parameters": [
                     {
                         "type": "string",
-                        "description": "Path to the file or directory",
-                        "name": "path",
+                        "description": "Comma-separated list of specific files within the directory (required)",
+                        "name": "files",
                         "in": "query",
                         "required": true
                     },
-                    {
-                        "type": "string",
-                        "description": "Comma-separated list of specific files within the directory (optional)",
-                        "name": "files",
-                        "in": "query"
-                    },
                     {
                         "type": "boolean",
                         "description": "If true, sets 'Content-Disposition' to 'inline'. Otherwise, defaults to 'attachment'.",
@@ -133,7 +127,7 @@ const docTemplate = `{
                     },
                     {
                         "type": "string",
-                        "description": "Compression algorithm for archiving multiple files or directories. Options: 'zip', 'tar', 'targz', 'tarbz2', 'tarxz', 'tarlz4', 'tarsz'. Default is 'zip'.",
+                        "description": "Compression algorithm for archiving multiple files or directories. Options: 'zip' and 'tar.gz'. Default is 'zip'.",
                         "name": "algo",
                         "in": "query"
                     }
@@ -172,15 +166,6 @@ const docTemplate = `{
                             }
                         }
                     },
-                    "415": {
-                        "description": "Unsupported file type for preview",
-                        "schema": {
-                            "type": "object",
-                            "additionalProperties": {
-                                "type": "string"
-                            }
-                        }
-                    },
                     "500": {
                         "description": "Internal server error",
                         "schema": {
@@ -594,7 +579,7 @@ const docTemplate = `{
                         "schema": {
                             "type": "array",
                             "items": {
-                                "$ref": "#/definitions/files.searchResult"
+                                "$ref": "#/definitions/files.SearchResult"
                             }
                         }
                     },
@@ -1155,22 +1140,16 @@ const docTemplate = `{
         "files.FileInfo": {
             "type": "object",
             "properties": {
-                "checksums": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "type": "string"
-                    }
-                },
-                "content": {
-                    "type": "string"
-                },
-                "isSymlink": {
-                    "type": "boolean"
-                },
-                "items": {
+                "files": {
                     "type": "array",
                     "items": {
-                        "$ref": "#/definitions/files.ReducedItem"
+                        "$ref": "#/definitions/files.ItemInfo"
+                    }
+                },
+                "folders": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/files.ItemInfo"
                     }
                 },
                 "modified": {
@@ -1185,26 +1164,14 @@ const docTemplate = `{
                 "size": {
                     "type": "integer"
                 },
-                "subtitles": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                },
-                "token": {
-                    "type": "string"
-                },
                 "type": {
                     "type": "string"
                 }
             }
         },
-        "files.ReducedItem": {
+        "files.ItemInfo": {
             "type": "object",
             "properties": {
-                "content": {
-                    "type": "string"
-                },
                 "modified": {
                     "type": "string"
                 },
@@ -1219,7 +1186,7 @@ const docTemplate = `{
                 }
             }
         },
-        "files.searchResult": {
+        "files.SearchResult": {
             "type": "object",
             "properties": {
                 "path": {

backend/swagger/docs/swagger.json

@@ -103,17 +103,11 @@
                 "parameters": [
                     {
                         "type": "string",
-                        "description": "Path to the file or directory",
-                        "name": "path",
+                        "description": "Comma-separated list of specific files within the directory (required)",
+                        "name": "files",
                         "in": "query",
                         "required": true
                     },
-                    {
-                        "type": "string",
-                        "description": "Comma-separated list of specific files within the directory (optional)",
-                        "name": "files",
-                        "in": "query"
-                    },
                     {
                         "type": "boolean",
                         "description": "If true, sets 'Content-Disposition' to 'inline'. Otherwise, defaults to 'attachment'.",
@@ -122,7 +116,7 @@
                     },
                     {
                         "type": "string",
-                        "description": "Compression algorithm for archiving multiple files or directories. Options: 'zip', 'tar', 'targz', 'tarbz2', 'tarxz', 'tarlz4', 'tarsz'. Default is 'zip'.",
+                        "description": "Compression algorithm for archiving multiple files or directories. Options: 'zip' and 'tar.gz'. Default is 'zip'.",
                         "name": "algo",
                         "in": "query"
                     }
@@ -161,15 +155,6 @@
                             }
                         }
                     },
-                    "415": {
-                        "description": "Unsupported file type for preview",
-                        "schema": {
-                            "type": "object",
-                            "additionalProperties": {
-                                "type": "string"
-                            }
-                        }
-                    },
                     "500": {
                         "description": "Internal server error",
                         "schema": {
@@ -583,7 +568,7 @@
                         "schema": {
                             "type": "array",
                             "items": {
-                                "$ref": "#/definitions/files.searchResult"
+                                "$ref": "#/definitions/files.SearchResult"
                             }
                         }
                     },
@@ -1144,22 +1129,16 @@
         "files.FileInfo": {
             "type": "object",
             "properties": {
-                "checksums": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "type": "string"
-                    }
-                },
-                "content": {
-                    "type": "string"
-                },
-                "isSymlink": {
-                    "type": "boolean"
-                },
-                "items": {
+                "files": {
                     "type": "array",
                     "items": {
-                        "$ref": "#/definitions/files.ReducedItem"
+                        "$ref": "#/definitions/files.ItemInfo"
+                    }
+                },
+                "folders": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/files.ItemInfo"
                     }
                 },
                 "modified": {
@@ -1174,26 +1153,14 @@
                 "size": {
                     "type": "integer"
                 },
-                "subtitles": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                },
-                "token": {
-                    "type": "string"
-                },
                 "type": {
                     "type": "string"
                 }
             }
         },
-        "files.ReducedItem": {
+        "files.ItemInfo": {
             "type": "object",
             "properties": {
-                "content": {
-                    "type": "string"
-                },
                 "modified": {
                     "type": "string"
                 },
@@ -1208,7 +1175,7 @@
                 }
             }
         },
-        "files.searchResult": {
+        "files.SearchResult": {
             "type": "object",
             "properties": {
                 "path": {

backend/swagger/docs/swagger.yaml

@@ -1,17 +1,13 @@
 definitions:
   files.FileInfo:
     properties:
-      checksums:
-        additionalProperties:
-          type: string
-        type: object
-      content:
-        type: string
-      isSymlink:
-        type: boolean
-      items:
+      files:
         items:
-          $ref: '#/definitions/files.ReducedItem'
+          $ref: '#/definitions/files.ItemInfo'
+        type: array
+      folders:
+        items:
+          $ref: '#/definitions/files.ItemInfo'
         type: array
       modified:
         type: string
@@ -21,19 +17,11 @@ definitions:
         type: string
       size:
         type: integer
-      subtitles:
-        items:
-          type: string
-        type: array
-      token:
-        type: string
       type:
         type: string
     type: object
-  files.ReducedItem:
+  files.ItemInfo:
     properties:
-      content:
-        type: string
       modified:
         type: string
       name:
@@ -43,7 +31,7 @@ definitions:
       type:
         type: string
     type: object
-  files.searchResult:
+  files.SearchResult:
     properties:
       path:
         type: string
@@ -350,14 +338,10 @@ paths:
       description: Returns the raw content of a file, multiple files, or a directory.
         Supports downloading files as archives in various formats.
       parameters:
-      - description: Path to the file or directory
-        in: query
-        name: path
-        required: true
-        type: string
-      - description: Comma-separated list of specific files within the directory (optional)
+      - description: Comma-separated list of specific files within the directory (required)
         in: query
         name: files
+        required: true
         type: string
       - description: If true, sets 'Content-Disposition' to 'inline'. Otherwise, defaults
           to 'attachment'.
@@ -365,8 +349,7 @@ paths:
         name: inline
         type: boolean
       - description: 'Compression algorithm for archiving multiple files or directories.
-          Options: ''zip'', ''tar'', ''targz'', ''tarbz2'', ''tarxz'', ''tarlz4'',
-          ''tarsz''. Default is ''zip''.'
+          Options: ''zip'' and ''tar.gz''. Default is ''zip''.'
         in: query
         name: algo
         type: string
@@ -395,12 +378,6 @@ paths:
             additionalProperties:
               type: string
             type: object
-        "415":
-          description: Unsupported file type for preview
-          schema:
-            additionalProperties:
-              type: string
-            type: object
         "500":
           description: Internal server error
           schema:
@@ -681,7 +658,7 @@ paths:
           description: List of search results
           schema:
             items:
-              $ref: '#/definitions/files.searchResult'
+              $ref: '#/definitions/files.SearchResult'
             type: array
         "400":
           description: Bad Request

backend/users/storage.go

@@ -4,7 +4,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/errors"
 )
 
 // StorageBackend is the interface to implement for a users storage.

backend/utils/cache.go

@@ -0,0 +1,80 @@
+package utils
+
+import (
+	"sync"
+	"time"
+)
+
+var (
+	DiskUsageCache     = newCache(30*time.Second, 24*time.Hour)
+	RealPathCache      = newCache(48*time.Hour, 72*time.Hour)
+	SearchResultsCache = newCache(15*time.Second, time.Hour)
+)
+
+func newCache(expires time.Duration, cleanup time.Duration) *KeyCache {
+	newCache := KeyCache{
+		data:         make(map[string]cachedValue),
+		expiresAfter: expires, // default
+	}
+	go newCache.cleanupExpiredJob(cleanup)
+	return &newCache
+}
+
+type KeyCache struct {
+	data         map[string]cachedValue
+	mu           sync.RWMutex
+	expiresAfter time.Duration
+}
+
+type cachedValue struct {
+	value     interface{}
+	expiresAt time.Time
+}
+
+func (c *KeyCache) Set(key string, value interface{}) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.data[key] = cachedValue{
+		value:     value,
+		expiresAt: time.Now().Add(c.expiresAfter),
+	}
+}
+
+func (c *KeyCache) SetWithExp(key string, value interface{}, exp time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.data[key] = cachedValue{
+		value:     value,
+		expiresAt: time.Now().Add(exp),
+	}
+}
+
+func (c *KeyCache) Get(key string) interface{} {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	cached, ok := c.data[key]
+	if !ok || time.Now().After(cached.expiresAt) {
+		return nil
+	}
+	return cached.value
+}
+
+func (c *KeyCache) cleanupExpired() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	now := time.Now()
+	for key, cached := range c.data {
+		if now.After(cached.expiresAt) {
+			delete(c.data, key)
+		}
+	}
+}
+
+// should automatically run for all cache types as part of init.
+func (c *KeyCache) cleanupExpiredJob(frequency time.Duration) {
+	ticker := time.NewTicker(frequency)
+	defer ticker.Stop()
+	for range ticker.C {
+		c.cleanupExpired()
+	}
+}

backend/utils/main.go

@@ -69,3 +69,18 @@ func PrintStructFields(v interface{}) {
 		fmt.Printf("Field: %s, %s\n", fieldType.Name, fieldValue)
 	}
 }
+
+func GetParentDirectoryPath(path string) string {
+	if path == "/" || path == "" {
+		return ""
+	}
+	path = strings.TrimSuffix(path, "/") // Remove trailing slash if any
+	lastSlash := strings.LastIndex(path, "/")
+	if lastSlash == -1 {
+		return "" // No parent directory for a relative path without slashes
+	}
+	if lastSlash == 0 {
+		return "/" // If the last slash is the first character, return root
+	}
+	return path[:lastSlash]
+}

backend/utils/main_test.go

@@ -0,0 +1,59 @@
+package utils
+
+import (
+	"testing"
+)
+
+func TestGetParentDirectoryPath(t *testing.T) {
+	tests := []struct {
+		input          string
+		expectedOutput string
+	}{
+		{input: "/", expectedOutput: ""},                                              // Root directory
+		{input: "/subfolder", expectedOutput: "/"},                                    // Single subfolder
+		{input: "/sub/sub/", expectedOutput: "/sub"},                                  // Nested subfolder with trailing slash
+		{input: "/subfolder/", expectedOutput: "/"},                                   // Relative path with trailing slash
+		{input: "", expectedOutput: ""},                                               // Empty string treated as root
+		{input: "/sub/subfolder", expectedOutput: "/sub"},                             // Double slash in path
+		{input: "/sub/subfolder/deep/nested/", expectedOutput: "/sub/subfolder/deep"}, // Double slash in path
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			actualOutput := GetParentDirectoryPath(test.input)
+			if actualOutput != test.expectedOutput {
+				t.Errorf("\n\tinput %q\n\texpected %q\n\tgot %q",
+					test.input, test.expectedOutput, actualOutput)
+			}
+		})
+	}
+}
+
+func TestCapitalizeFirst(t *testing.T) {
+	tests := []struct {
+		input          string
+		expectedOutput string
+	}{
+		{input: "", expectedOutput: ""},                               // Empty string
+		{input: "a", expectedOutput: "A"},                             // Single lowercase letter
+		{input: "A", expectedOutput: "A"},                             // Single uppercase letter
+		{input: "hello", expectedOutput: "Hello"},                     // All lowercase
+		{input: "Hello", expectedOutput: "Hello"},                     // Already capitalized
+		{input: "123hello", expectedOutput: "123hello"},               // Non-alphabetic first character
+		{input: "hELLO", expectedOutput: "HELLO"},                     // Mixed case
+		{input: " hello", expectedOutput: " hello"},                   // Leading space, no capitalization
+		{input: "hello world", expectedOutput: "Hello world"},         // Phrase with spaces
+		{input: " hello world", expectedOutput: " hello world"},       // Phrase with leading space
+		{input: "123 hello world", expectedOutput: "123 hello world"}, // Numbers before text
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			actualOutput := CapitalizeFirst(test.input)
+			if actualOutput != test.expectedOutput {
+				t.Errorf("\n\tinput %q\n\texpected %q\n\tgot %q",
+					test.input, test.expectedOutput, actualOutput)
+			}
+		})
+	}
+}

docs/configuration.md

@@ -10,7 +10,6 @@ Here is an expanded config file which includes all possible configurations:
 server:
   CreateUserDir: false
   UserHomeBasePath: ""
-  indexingInterval: 5
   indexing: true
   numImageProcessors: 4
   socket: ""
@@ -71,7 +70,6 @@ Here are the defaults if nothing is set:
 server:
   enableThumbnails: true
   enableExec: false
-  indexingInterval: 5
   port: 80
   numImageProcessors: 4
   baseURL: ""
@@ -109,7 +107,7 @@ userDefaults:
 
 ### Server configuration settings
 
-- `indexingInterval`: This is the time in minutes the system waits before checking for filesystem changes. Default: `5`
+- `indexingInterval`: This optional paramter disables smart indexing and specifies a time in minutes the system waits before checking for filesystem changes. See [indexing readme](indexing.md) for more information.
 
 - `indexing`: This enables or disables indexing. (Note: search will not work without indexing) Default: `true`
 

docs/contributing.md

@@ -1,2 +1,13 @@
 # Contributing Guide
 
+If you would like to contribute, please open a pull request against main or the latest `dev_` branch thats currently in progress.
+
+A PR is required to have:
+
+1. A clear description about why it was opened
+2. A short title that best describes the issue.
+3. Test evidence for anything that is not self evident or covered by unit tests.
+
+Unit tests should be updated to pass before merging. So, the best way to handle this is to create a fork and test your changes there, then merge to this repo. You can also create a draft pull request if it is not fully ready.
+
+Please don't hesitate to open an issue for any ideas you have, but cannot contribute directly for whatever reason.

docs/indexing.md

@@ -0,0 +1,189 @@
+# About Indexing on FileBrowser Quantum
+
+The most significant feature is the index, this document intends to demystify how it works so you can understand how to ensure your index closely matches the current state of your filesystem.
+
+## How does the index work?
+
+The approach used by this repo includes filesystem watchers that periodically scan the directory tree for changes. By default, this uses a smart scan strategy, but you can also configure a set interval in your config file.
+
+The `scan interval` is the break time between scans and does not include the time a scan takes. A typical scan can vary dramatically, but here are some expectations for SSD-based disks:
+
+| # folders  | # files  | time to index  | memory usage (RAM) |
+|---|---|---|---|
+|  10,000 | 10,000 | ~ 0-5 seconds | 15 MB |
+| 2,000  | 250,000 | ~ 0-5 seconds | 300 MB |
+| 50,000  | 50,000 | ~ 5-30 seconds | 150 MB |
+| 250,000  | 10,000 | ~ 2-5 minutes | 300 MB |
+| 500,000  | 500,000 | ~ 5+ minutes | 500+ MB |
+
+### Smart Scanning
+
+1. There is a floating `smart scan interval` that ranges from **1 minute - 4 hours** depending on the complexity of your filesystem
+2. The smart interval changes based on how often it discovers changed files:
+  - ```
+        // Schedule in minutes
+        var scanSchedule = []time.Duration{
+            5 * time.Minute, // 5 minute quick scan & 25 minutes for a full scan
+            10 * time.Minute,
+            20 * time.Minute, // [3] element is 20 minutes, reset anchor for full scan
+            40 * time.Minute,
+            1 * time.Hour,
+            2 * time.Hour,
+            3 * time.Hour,
+            4 * time.Hour, // 4 hours for quick scan & 20 hours for a full scan
+        }
+    ```
+3. The `smart scan interval` performs a `quick scan` 4 times in a row, followed by a 5th `full scan` which completely rebuilds the index.
+   - A `quick scan` is limited to detecting directory changes, but is 10x faster than a full scan. Here is what a quick scan can see:
+      1. New files or folders created.
+      2. Files or folders deleted.
+      3. Renaming of files or folders.
+   - A quick scan **cannot** detect when a file has been updated, for example when you save a file and the size increases.
+   - A `full scan` is a complete re-indexing. This is always more disk and computationally intense but will capture individual file changes.
+4. The `smart scan interval` changes based on several things. A `simple` complexity enables scans every 1 minute if changes happen frequently and a maximum full scan interval of every 100 minutes. `high` complexity indicates a minimum scanning interval of 10 minutes.
+   - **under 10,000 folders** or **Under 3 seconds** to index is awlays considered `simple` complexity.
+   - **more than 500,000 folders** or **Over 2 minutes** to index is always considered `high` complexity.
+
+### Manual Scanning Interval
+
+If you don't like the behavior of smart scanning, you can configure set intervals instead by setting `indexingInterval` to a number greater than 0. This will make FileBrowser Quantum always scan at the given interval in minutes.
+
+The scan behavior is still 4 quick scans at a given interval, followed by a 5th full scan.
+
+### System requirements
+
+You can expect FileBrowser Quantum to use 100 MB of RAM for a typical installation. If you have many files and folders then the requirement could climb to multiple Gigabytes. Please monitor your system on the first run to know your specific requirements.
+
+### Why does FileBrowser Quantum index the way it does?
+
+The smart indexing method uses filesystem scanners because it allows a low-footprint design that can cater to individual filesystem complexity. There are a few options for monitoring a filesystem for changes:
+
+1. **Option 1**: Recursive Traversal with ReadDir
+  - This is quite computationally intensive but creates an accurate record of the filesystem
+  - Requires periodic scanning to remain updated
+  - Low overhead and straightforward implementation.
+2. **Option 2**: Use File System Monitoring (Real-Time or Periodic Check) such as `fsnotify`
+  - This allows for event-based reactions to filesystem changes.
+  - Requires extra overhead.
+  - Relies on OS level features and behavior differs between OS's
+  - Requires OS-level configuration to ulimits in order to properly watch a large filesystem.
+3. **Option 3**: Directory Metadata Heuristics.
+  - Using ModTime to determine when directory structures change.
+  - Has minimal insight into actual file changes.
+  - Much faster to scan for changes than Recursive transversal.
+
+Ultimately, FileBrowser Quantum uses a combination of 1 and 3 to perform index updates. Using something like fsnotify is a non-starter for large filesystems, where it would require manual host OS tuning to work at all. Besides, I can essentially offer the same behavior by creating "watchers" for top-level folders (a feature to come in the future). However, right now there is a single root-level watcher that works over the entire index.
+
+The main disadvantage of the approach is the delay caused by the scanning interval.
+
+### How to manually refresh the index?
+
+There is currently no way to manually trigger a new full indexing. This will come in a future release when the "jobs" functionality is added back.
+
+However, if you want to force-refresh a certain directory, this happens every time you **view it** in the UI or via the resources API.
+
+This also means the resources API is always up to date with the current status of the filesystem. When you "look" at a specific folder, you are causing the index to be refreshed at that location.
+
+### What information does the index have?
+
+You can see what the index looks like by using the resources API via the GET method, which returns individual directory information -- all of this information is stored in the index.
+
+Here is an example:
+
+```
+{
+    "name": "filebrowser",
+    "size": 274467914,
+    "modified": "2024-11-23T19:18:57.68013727-06:00",
+    "type": "directory",
+    "files": [
+        {
+            "name": ".dockerignore",
+            "size": 73,
+            "modified": "2024-11-20T18:14:44.91135413-06:00",
+            "type": "blob"
+        },
+        {
+            "name": ".DS_Store",
+            "size": 6148,
+            "modified": "2024-11-22T14:45:15.901211088-06:00",
+            "type": "blob"
+        },
+        {
+            "name": ".gitignore",
+            "size": 455,
+            "modified": "2024-11-23T19:18:57.616132373-06:00",
+            "type": "blob"
+        },
+        {
+            "name": "CHANGELOG.md",
+            "size": 9325,
+            "modified": "2024-11-23T19:18:57.616646332-06:00",
+            "type": "text"
+        },
+        {
+            "name": "Dockerfile",
+            "size": 769,
+            "modified": "2024-11-23T19:18:57.616941333-06:00",
+            "type": "blob"
+        },
+        {
+            "name": "Dockerfile.playwright",
+            "size": 542,
+            "modified": "2024-11-23T19:18:57.617151875-06:00",
+            "type": "blob"
+        },
+        {
+            "name": "makefile",
+            "size": 1311,
+            "modified": "2024-11-23T19:18:57.68017352-06:00",
+            "type": "blob"
+        },
+        {
+            "name": "README.md",
+            "size": 10625,
+            "modified": "2024-11-23T19:18:57.617464334-06:00",
+            "type": "text"
+        }
+    ],
+    "folders": [
+        {
+            "name": ".git",
+            "size": 60075460,
+            "modified": "2024-11-24T14:44:42.52180215-06:00",
+            "type": "directory"
+        },
+        {
+            "name": ".github",
+            "size": 11584,
+            "modified": "2024-11-20T18:14:44.911805335-06:00",
+            "type": "directory"
+        },
+        {
+            "name": "backend",
+            "size": 29247172,
+            "modified": "2024-11-23T19:18:57.667109624-06:00",
+            "type": "directory"
+        },
+        {
+            "name": "docs",
+            "size": 14272,
+            "modified": "2024-11-24T13:46:12.082024018-06:00",
+            "type": "directory"
+        },
+        {
+            "name": "frontend",
+            "size": 185090178,
+            "modified": "2024-11-24T14:44:39.880678934-06:00",
+            "type": "directory"
+        }
+    ],
+    "path": "/filebrowser"
+}
+```
+
+### Can I disable the index and still use FileBrowser Quantum?
+
+You can disable the index by setting `indexing: false` in your config file. You will still be able to browse your files, but the search will not work and you may run into issues as it's not intended to be used without indexing.
+
+I'm not sure why you would run it like this, if you have a good reason please open an issue request on how you would like it to work -- and why you would run it without the index.

docs/roadmap.md

@@ -1,18 +1,17 @@
 # Planned Roadmap
 
-upcoming 0.3.x releases:
-
-- Theme configuration from settings
-- File synchronization improvements
-- more filetype previews
-- introduce jobs as replacement to runners.
-  - Add Job status to the sidebar
-  - index status.
-  - Job status from users
-  - upload status
-- opentelemetry metrics
-- simple search/filter for current listings.
-- Enable mobile search with same features as desktop
+upcoming 0.3.x releases, ordered by priority:
+  - more indexing flexability
+    - option not to index hidden files/folders
+    - options folders to include/exclude from indexing
+    - implement more indexing runners for more efficienct filesystem watching
+  - more filetype previews: eg. raw img, office, photoshop, vector, 3d files.
+  - introduce jobs as replacement to runners.
+    - Add Job status to the sidebar
+    - index status.
+    - Job status from users
+    - upload status
+  - opentelemetry metrics
 
 Unplanned Future releases:
   - multiple sources https://github.com/filebrowser/filebrowser/issues/2514

frontend/package.json

@@ -13,10 +13,11 @@
     "build-docker": "vite build",
     "watch": "vite build --watch",
     "typecheck": "vue-tsc -p ./tsconfig.json --noEmit",
-    "lint": "npm run typecheck && eslint src/",
+    "lint": "eslint --ext .js,.vue,ts src",
     "lint:fix": "eslint --fix src/",
     "format": "prettier --write .",
-    "test": "npx playwright test"
+    "integration-test": "npx playwright test",
+    "test": "vitest run "
   },
   "dependencies": {
     "ace-builds": "^1.24.2",
@@ -24,6 +25,7 @@
     "css-vars-ponyfill": "^2.4.3",
     "file-loader": "^6.2.0",
     "material-icons": "^1.10.5",
+    "material-symbols": "^0.27.2",
     "normalize.css": "^8.0.1",
     "qrcode.vue": "^3.4.1",
     "vue": "^3.4.21",
@@ -32,15 +34,17 @@
     "vue-router": "^4.3.0"
   },
   "devDependencies": {
-    "@playwright/test": "^1.42.1",
     "@intlify/unplugin-vue-i18n": "^4.0.0",
+    "@playwright/test": "^1.42.1",
     "@vitejs/plugin-vue": "^5.0.4",
     "@vue/eslint-config-typescript": "^13.0.0",
     "eslint": "^8.57.0",
-    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-vue": "^9.24.0",
+    "jsdom": "^25.0.1",
     "vite": "^5.2.7",
     "vite-plugin-compression2": "^1.0.0",
+    "vitest": "^2.1.5",
     "vue-tsc": "^2.0.7"
   }
 }

frontend/src/api/files.js

@@ -1,17 +1,17 @@
-import { createURL, fetchURL, adjustedData} from "./utils";
-import { baseURL } from "@/utils/constants";
-import { removePrefix,getApiPath } from "@/utils/url.js";
+import { fetchURL, adjustedData } from "./utils";
+import { removePrefix, getApiPath } from "@/utils/url.js";
 import { state } from "@/store";
 import { notify } from "@/notify";
 
 // Notify if errors occur
 export async function fetchFiles(url, content = false) {
   try {
-    url = removePrefix(url,"files");
-    const apiPath = getApiPath("api/resources",{path: url, content: content});
+    let path = encodeURIComponent(removePrefix(url, "files"));
+    const apiPath = getApiPath("api/resources",{path: path, content: content});
     const res = await fetchURL(apiPath);
     const data = await res.json();
-    return adjustedData(data,url);
+    const adjusted = adjustedData(data, url);
+    return adjusted;
   } catch (err) {
     notify.showError(err.message || "Error fetching data");
     throw err;
@@ -24,7 +24,8 @@ async function resourceAction(url, method, content) {
     if (content) {
       opts.body = content;
     }
-    const apiPath = getApiPath("api/resources", { path: url });
+    let path = encodeURIComponent(removePrefix(url, "files"));
+    const apiPath = getApiPath("api/resources", { path: path });
     const res = await fetchURL(apiPath, opts);
     return res;
   } catch (err) {
@@ -35,7 +36,8 @@ async function resourceAction(url, method, content) {
 
 export async function remove(url) {
   try {
-    return await resourceAction(url, "DELETE");
+    let path = encodeURIComponent(removePrefix(url, "files"));
+    return await resourceAction(path, "DELETE");
   } catch (err) {
     notify.showError(err.message || "Error deleting resource");
     throw err;
@@ -44,34 +46,30 @@ export async function remove(url) {
 
 export async function put(url, content = "") {
   try {
-    return await resourceAction(url, "PUT", content);
+    let path = encodeURIComponent(removePrefix(url, "files"));
+    return await resourceAction(path, "PUT", content);
   } catch (err) {
     notify.showError(err.message || "Error putting resource");
     throw err;
   }
 }
 
-export function download(format, ...files) {
+export function download(format, files) {
+  if (format != "zip") {
+    format = "tar.gz"
+  }
   try {
-    let url = `${baseURL}/api/raw`;
+    let fileargs = "";
     if (files.length === 1) {
-      url +=  "?path="+removePrefix(files[0], "files");
+      fileargs = decodeURI(removePrefix(files[0], "files"))
     } else {
-      let arg = "";
-
       for (let file of files) {
-        arg += removePrefix(file,"files") + ",";
+        fileargs += decodeURI(removePrefix(file,"files")) + ",";
       }
-
-      arg = arg.substring(0, arg.length - 1);
-      arg = encodeURIComponent(arg);
-      url += `?files=${arg}`;
+      fileargs = fileargs.substring(0, fileargs.length - 1);
     }
-
-    if (format) {
-      url += `&algo=${format}`;
-    }
-
+    const apiPath = getApiPath("api/raw", { files: encodeURIComponent(fileargs), algo: format });
+    const url = window.origin+apiPath
     window.open(url);
   } catch (err) {
     notify.showError(err.message || "Error downloading files");
@@ -135,9 +133,11 @@ export async function moveCopy(items, action = "copy", overwrite = false, rename
   }
   try {
     for (let item of items) {
+      let toPath = encodeURIComponent(removePrefix(decodeURI(item.to), "files"));
+      let fromPath = encodeURIComponent(removePrefix(decodeURI(item.from), "files"));
       let localParams = { ...params };
-      localParams.destination = item.to;
-      localParams.from = item.from;
+      localParams.destination = toPath;
+      localParams.from = fromPath;
       const apiPath = getApiPath("api/resources", localParams);
       promises.push(fetch(apiPath, { method: "PATCH" }));
     }
@@ -162,10 +162,11 @@ export async function checksum(url, algo) {
 export function getDownloadURL(path, inline) {
   try {
     const params = {
-      path: path,
+      files: encodeURIComponent(removePrefix(decodeURI(path),"files")),
       ...(inline && { inline: "true" }),
     };
-    return createURL("api/raw", params);
+    const apiPath = getApiPath("api/raw", params);
+    return window.origin+apiPath
   } catch (err) {
     notify.showError(err.message || "Error getting download URL");
     throw err;
@@ -175,13 +176,13 @@ export function getDownloadURL(path, inline) {
 export function getPreviewURL(path, size, modified) {
   try {
     const params = {
-      path: path,
+      path: encodeURIComponent(removePrefix(decodeURI(path),"files")),
       size: size,
       key: Date.parse(modified),
       inline: "true",
     };
-
-    return createURL("api/preview", params);
+    const apiPath = getApiPath("api/preview", params);
+    return window.origin+apiPath
   } catch (err) {
     notify.showError(err.message || "Error getting preview URL");
     throw err;
@@ -190,13 +191,14 @@ export function getPreviewURL(path, size, modified) {
 
 export function getSubtitlesURL(file) {
   try {
-    const params = {
-      inline: "true",
-    };
-
     const subtitles = [];
     for (const sub of file.subtitles) {
-      subtitles.push(createURL("api/raw" + sub, params));
+      const params = {
+        inline: "true",
+        path: encodeURIComponent(removePrefix(sub,"files"))
+      };
+      const apiPath = getApiPath("api/raw", params);
+      return window.origin+apiPath
     }
 
     return subtitles;

frontend/src/api/public.js

@@ -1,53 +1,47 @@
-import { createURL, adjustedData } from "./utils";
-import { getApiPath } from "@/utils/url.js";
+import { adjustedData } from "./utils";
+import { getApiPath, removePrefix } from "@/utils/url.js";
 import { notify } from "@/notify";
 
 // Fetch public share data
 export async function fetchPub(path, hash, password = "") {
-  try {
-    const params = { path, hash }
-    const apiPath = getApiPath("api/public/share", params);
-    const response = await fetch(apiPath, {
-      headers: {
-        "X-SHARE-PASSWORD": password ? encodeURIComponent(password) : "",
-      },
-    });
+  const params = { path, hash }
+  const apiPath = getApiPath("api/public/share", params);
+  const response = await fetch(apiPath, {
+    headers: {
+      "X-SHARE-PASSWORD": password ? encodeURIComponent(password) : "",
+    },
+  });
 
-    if (!response.ok) {
-      const error = new Error("Failed to connect to the server.");
-      error.status = response.status;
-      throw error;
-    }
-    let data = await response.json()
-    return adjustedData(data, `${hash}${path}`);
-  } catch (err) {
-    notify.showError(err.message || "Error fetching public share data");
-    throw err;
+  if (!response.ok) {
+    const error = new Error("Failed to connect to the server.");
+    error.status = response.status;
+    throw error;
   }
+  let data = await response.json()
+  const adjusted = adjustedData(data, getApiPath(`share/${hash}${path}`));
+  return adjusted
 }
 
 // Download files with given parameters
-export function download(path, hash, token, format, ...files) {
+export function download(share, ...files) {
   try {
     let fileInfo = files[0]
     if (files.length > 1) {
       fileInfo = files.map(encodeURIComponent).join(",");
     }
     const params = {
-      path,
-      hash,
-      ...(format && { format}),
-      ...(token && { token }),
-      fileInfo
+      "path": removePrefix(share.path, "share"),
+      "hash": share.hash,
+      "token": share.token,
+      "inline": share.inline,
+      "files": fileInfo,
     };
-    const url = createURL(`api/public/dl`, params, false);
-    window.open(url);
+    const apiPath = getApiPath("api/public/dl", params);
+    window.open(window.origin+apiPath)
   } catch (err) {
     notify.showError(err.message || "Error downloading files");
     throw err;
   }
-
-
 }
 
 // Get the public user data
@@ -64,11 +58,6 @@ export async function getPublicUser() {
 
 // Generate a download URL
 export function getDownloadURL(share) {
-  const params = {
-    "path": share.path,
-    "hash": share.hash,
-    "token": share.token,
-    ...(share.inline && { inline: "true" }),
-  };
-  return createURL(`api/public/dl`, params, false);
+  const apiPath = getApiPath("api/public/dl", share);
+  return window.origin+apiPath
 }

frontend/src/api/share.js

@@ -1,15 +1,17 @@
-import { fetchURL, fetchJSON, createURL, adjustedData } from "./utils";
+import { fetchURL, fetchJSON, adjustedData } from "./utils";
 import { notify } from "@/notify";
+import { getApiPath } from "@/utils/url.js";
 
 export async function list() {
-  return fetchJSON("api/shares");
+  const apiPath = getApiPath("api/shares");
+  return fetchJSON(apiPath);
 }
 
 export async function get(path, hash) {
   try {
     const params = { path, hash };
-    const url = createURL(`api/share`, params, false);
-    let data = fetchJSON(url);
+    const apiPath = getApiPath("api/share",params);
+    let data = fetchJSON(apiPath);
     return adjustedData(data, `api/share${path}`);
   } catch (err) {
     notify.showError(err.message || "Error fetching data");
@@ -19,25 +21,25 @@ export async function get(path, hash) {
 
 export async function remove(hash) {
   const params = { hash };
-  const url = createURL(`api/share`, params, false);
-  await fetchURL(url, {
+  const apiPath = getApiPath("api/share",params);
+  await fetchURL(apiPath, {
     method: "DELETE",
   });
 }
 
 export async function create(path, password = "", expires = "", unit = "hours") {
   const params = { path };
-  const url = createURL(`api/share`, params, false);
+  const apiPath = getApiPath("api/share",params);
   let body = "{}";
   if (password != "" || expires !== "" || unit !== "hours") {
     body = JSON.stringify({ password: password, expires: expires, unit: unit });
   }
-  return fetchJSON(url, {
+  return fetchJSON(apiPath, {
     method: "POST",
     body: body,
   });
 }
 
 export function getShareURL(share) {
-  return createURL("share/" + share.hash, {}, false);
+  return window.origin+getApiPath(`share/${share.hash}`);
 }

frontend/src/api/users.js

@@ -60,7 +60,8 @@ export function deleteApiKey(params) {
 
 export async function create(user) {
   try {
-    const res = await fetchURL(`api/users`, {
+    const apiPath = getApiPath("api/users");
+    const res = await fetchURL(apiPath, {
       method: "POST",
       body: JSON.stringify({
         what: "user",

frontend/src/api/utils.js

@@ -1,6 +1,5 @@
 import { state } from "@/store";
 import { renew, logout } from "@/utils/auth";
-import { baseURL } from "@/utils/constants";
 import { notify } from "@/notify";
 
 export async function fetchURL(url, opts, auth = true) {
@@ -24,9 +23,11 @@ export async function fetchURL(url, opts, auth = true) {
       ...rest,
     });
   } catch (e) {
-    console.error(e)
-    const error = new Error("000 No connection");
-    error.status = res.status;
+    let message = e;
+    if (e == "TypeError: Failed to fetch") {
+      message = "Failed to connect to the server, is it still running?";
+    }
+    const error = new Error(message);
     throw error;
   }
 
@@ -35,7 +36,7 @@ export async function fetchURL(url, opts, auth = true) {
   }
 
   if (res.status < 200 || res.status > 299) {
-    const error = new Error(await res.text());
+    let error = new Error(await res.text());
     error.status = res.status;
 
     if (auth && res.status == 401) {
@@ -58,36 +59,28 @@ export async function fetchJSON(url, opts) {
   }
 }
 
-export function createURL(endpoint, params = {}) {
-  let prefix = baseURL;
-  if (!prefix.endsWith("/")) {
-    prefix = prefix + "/";
-  }
-  const url = new URL(prefix + endpoint, origin);
-
-  const searchParams = {
-    ...params,
-  };
-
-  for (const key in searchParams) {
-    url.searchParams.set(key, searchParams[key]);
-  }
-
-  return url.toString();
-}
-
 export function adjustedData(data, url) {
   data.url = url;
-  if (data.type == "directory") {
+  if (data.type === "directory") {
     if (!data.url.endsWith("/")) data.url += "/";
+
+    // Combine folders and files into items
+    data.items = [...(data.folders || []), ...(data.files || [])];
+
     data.items = data.items.map((item, index) => {
       item.index = index;
       item.url = `${data.url}${item.name}`;
-      if (item.type == "directory") {
+      if (item.type === "directory") {
         item.url += "/";
       }
       return item;
     });
   }
-  return data
-}
+  if (data.files) {
+    data.files = []
+  }
+  if (data.folders) {
+    data.folders = []
+  }
+  return data;
+}

frontend/src/api/utils.test.js

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi } from 'vitest';
+import { adjustedData } from './utils.js';
+
+describe('adjustedData', () => {
+  it('should append the URL and process directory data correctly', () => {
+    const input = {
+      type: "directory",
+      folders: [
+        { name: "folder1", type: "directory" },
+        { name: "folder2", type: "directory" },
+      ],
+      files: [
+        { name: "file1.txt", type: "file" },
+        { name: "file2.txt", type: "file" },
+      ],
+    };
+
+    const url = "http://example.com/unit-testing/files/path/to/directory";
+
+    const expected = {
+      type: "directory",
+      url: "http://example.com/unit-testing/files/path/to/directory/",
+      folders: [],
+      files: [],
+      items: [
+        { name: "folder1", type: "directory", index: 0, url: "http://example.com/unit-testing/files/path/to/directory/folder1/" },
+        { name: "folder2", type: "directory", index: 1, url: "http://example.com/unit-testing/files/path/to/directory/folder2/" },
+        { name: "file1.txt", type: "file", index: 2, url: "http://example.com/unit-testing/files/path/to/directory/file1.txt" },
+        { name: "file2.txt", type: "file", index: 3, url: "http://example.com/unit-testing/files/path/to/directory/file2.txt" },
+      ],
+    };
+
+    expect(adjustedData(input, url)).toEqual(expected);
+  });
+
+  it('should add a trailing slash to the URL if missing for a directory', () => {
+    const input = { type: "directory", folders: [], files: [] };
+    const url = "http://example.com/base";
+
+    const expected = {
+      type: "directory",
+      url: "http://example.com/base/",
+      folders: [],
+      files: [],
+      items: [],
+    };
+
+    expect(adjustedData(input, url)).toEqual(expected);
+  });
+
+  it('should handle non-directory types without modification to items', () => {
+    const input = { type: "file", name: "file1.txt" };
+    const url = "http://example.com/base";
+
+    const expected = {
+      type: "file",
+      name: "file1.txt",
+      url: "http://example.com/base",
+    };
+
+    expect(adjustedData(input, url)).toEqual(expected);
+  });
+
+  it('should handle missing folders and files gracefully', () => {
+    const input = { type: "directory" };
+    const url = "http://example.com/base";
+
+    const expected = {
+      type: "directory",
+      url: "http://example.com/base/",
+      items: [],
+    };
+
+    expect(adjustedData(input, url)).toEqual(expected);
+  });
+
+  it('should handle empty input object correctly', () => {
+    const input = {};
+    const url = "http://example.com/base";
+
+    const expected = {
+      url: "http://example.com/base",
+    };
+
+    expect(adjustedData(input, url)).toEqual(expected);
+  });
+
+});
+
+vi.mock('@/utils/constants', () => {
+  return {
+    baseURL: "unit-testing",
+  };
+});
+

frontend/src/components/Breadcrumbs.vue

@@ -21,7 +21,6 @@
         type="range"
         id="gallery-size"
         name="gallery-size"
-        :value="gallerySize"
         min="0"
         max="10"
         @input="updateGallerySize"
@@ -62,6 +61,9 @@ export default {
       if (parts[0] === "") {
         parts.shift();
       }
+      if (getters.currentView() == "share") {
+        parts.shift();
+      }
 
       if (parts[parts.length - 1] === "") {
         parts.pop();

frontend/src/components/ButtonGroup.vue

@@ -80,6 +80,7 @@ export default {
 .button-group {
   margin: 1em;
   display: flex;
+  flex-wrap: wrap;
   border: 1px solid #ccc;
   border-radius: 1em;
   overflow: hidden;
@@ -93,7 +94,6 @@ button {
   border: none;
   background: #f5f5f5;
   transition: background-color 0.3s;
-
   /* Add borders */
   border-right: 1px solid #ccc;
 }

frontend/src/components/ContextMenu.vue

@@ -8,7 +8,7 @@
       left: `${left}px`,
     }"
     class="button"
-    :class="{ 'dark-mode': isDarkMode, mobile: isMobile }"
+    :class="{ 'dark-mode': isDarkMode, centered: centered }"
   >
     <div v-if="selectedCount > 0" class="button selected-count-header">
       <span>{{ selectedCount }} selected</span>
@@ -108,8 +108,8 @@ export default {
     user() {
       return state.user;
     },
-    isMobile() {
-      return getters.isMobile();
+    centered() {
+      return getters.isMobile() || ( !this.posX || !this.posY );
     },
     showContext() {
       if (getters.currentPromptName() == "ContextMenu" && state.prompts != []) {
@@ -122,14 +122,12 @@ export default {
       // Ensure the context menu stays within the viewport
       return Math.min(
         this.posY,
-
         window.innerHeight - (this.$refs.contextMenu?.clientHeight ?? 0)
       );
     },
     left() {
       return Math.min(
         this.posX,
-
         window.innerWidth - (this.$refs.contextMenu?.clientWidth ?? 0)
       );
     },
@@ -161,8 +159,24 @@ export default {
     },
     setPositions() {
       const contextProps = getters.currentPrompt().props;
-      this.posX = contextProps.posX;
-      this.posY = contextProps.posY;
+      let tempX = contextProps.posX;
+      let tempY = contextProps.posY;
+      // Assuming the screen width and height (adjust values based on your context)
+      const screenWidth = window.innerWidth; // or any fixed width depending on your app's layout
+      const screenHeight = window.innerHeight; // or any fixed height depending on your app's layout
+
+      // if x is too close to the right edge, move it to the left by 400px
+      if (tempX > screenWidth - 200) {
+        tempX -= 200;
+      }
+
+      // if y is too close to the bottom edge, move it up by 400px
+      if (tempY > screenHeight - 400) {
+        tempY -= 400;
+      }
+
+      this.posX = tempX;
+      this.posY = tempY;
     },
     toggleMultipleSelection() {
       mutations.setMultiple(!state.multiple);
@@ -189,7 +203,7 @@ export default {
   justify-content: center;
 }
 
-#context-menu.mobile {
+#context-menu.centered {
   top: 50% !important;
   left: 50% !important;
   -webkit-transform: translate(-50%, -50%);