Update docker file to add mechanicalsoup python library (#1688)

Add a new python library mechanicalsoup to the docker container.
There is a pending pull request in the Community scrapers for the Ifeelmyself that uses this library so it might be worth including it in the container.
This should add ~100k to the size of the container.

.github/workflows/build.yml

@@ -0,0 +1,185 @@
+name: Build
+
+on:
+  push:
+    branches: [ develop, master ]
+  pull_request:
+    branches: [ develop ]
+  release:
+    types: [ published ]
+
+env:
+  COMPILER_IMAGE: stashapp/compiler:4
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Checkout
+      run: git fetch --prune --unshallow --tags
+
+    - name: Pull compiler image
+      run: docker pull $COMPILER_IMAGE
+
+    - name: Cache node modules
+      uses: actions/cache@v2
+      env:
+        cache-name: cache-node_modules
+      with:
+        path: ui/v2.5/node_modules
+        key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('ui/v2.5/yarn.lock') }}
+
+    - name: Cache UI build
+      uses: actions/cache@v2
+      id: cache-ui
+      env:
+        cache-name: cache-ui
+      with:
+        path: ui/v2.5/build
+        key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('ui/v2.5/yarn.lock', 'ui/v2.5/public/**', 'ui/v2.5/src/**', 'graphql/**/*.graphql') }}
+
+    - name: Cache go build
+      uses: actions/cache@v2
+      env:
+        cache-name: cache-go-cache
+      with:
+        path: .go-cache
+        key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/go.sum') }}
+
+    - name: Start build container
+      run: |
+        mkdir -p .go-cache
+        docker run -d --name build --mount type=bind,source="$(pwd)",target=/stash,consistency=delegated --mount type=bind,source="$(pwd)/.go-cache",target=/root/.cache/go-build,consistency=delegated -w /stash $COMPILER_IMAGE tail -f /dev/null
+    
+    - name: Pre-install
+      run: docker exec -t build /bin/bash -c "make pre-ui"
+
+    - name: Generate
+      run: docker exec -t build /bin/bash -c "make generate"
+    
+    - name: Validate UI
+      # skip UI validation for pull requests if UI is unchanged
+      if: ${{ github.event_name != 'pull_request' || steps.cache-ui.outputs.cache-hit != 'true' }}
+      run: docker exec -t build /bin/bash -c "make ui-validate"
+
+    # TODO: Replace with `make validate` once `revive` is bundled in COMPILER_IMAGE
+    - name: Validate
+      run: docker exec -t build /bin/bash -c "make fmt-check vet it"
+
+    - name: Build UI
+      # skip UI build for pull requests if UI is unchanged (UI was cached)
+      # this means that the build version/time may be incorrect if the UI is
+      # not changed in a pull request
+      if: ${{ github.event_name != 'pull_request' || steps.cache-ui.outputs.cache-hit != 'true' }}
+      run: docker exec -t build /bin/bash -c "make ui-only"
+
+    - name: Compile for all supported platforms
+      run: |
+        docker exec -t build /bin/bash -c "make packr"
+        docker exec -t build /bin/bash -c "make cross-compile-windows"
+        docker exec -t build /bin/bash -c "make cross-compile-osx"
+        docker exec -t build /bin/bash -c "make cross-compile-linux"
+        docker exec -t build /bin/bash -c "make cross-compile-linux-arm64v8"
+        docker exec -t build /bin/bash -c "make cross-compile-linux-arm32v7"
+        docker exec -t build /bin/bash -c "make cross-compile-pi"
+
+    - name: Cleanup build container
+      run: docker rm -f -v build
+
+    - name: Generate checksums
+      run: |
+        git describe --tags --exclude latest_develop | tee CHECKSUMS_SHA1
+        sha1sum dist/stash-* | sed 's/dist\///g' | tee -a CHECKSUMS_SHA1
+        echo "STASH_VERSION=$(git describe --tags --exclude latest_develop)" >> $GITHUB_ENV
+        echo "RELEASE_DATE=$(date +'%Y-%m-%d %H:%M:%S %Z')" >> $GITHUB_ENV
+    
+    - name: Upload Windows binary
+      # only upload binaries for pull requests
+      if: ${{ github.event_name == 'pull_request' && github.base_ref != 'refs/heads/develop' && github.base_ref != 'refs/heads/master'}}
+      uses: actions/upload-artifact@v2
+      with:
+        name: stash-win.exe
+        path: dist/stash-win.exe
+
+    - name: Upload OSX binary
+      # only upload binaries for pull requests
+      if: ${{ github.event_name == 'pull_request' && github.base_ref != 'refs/heads/develop' && github.base_ref != 'refs/heads/master'}}
+      uses: actions/upload-artifact@v2
+      with:
+        name: stash-osx
+        path: dist/stash-osx
+
+    - name: Upload Linux binary
+      # only upload binaries for pull requests
+      if: ${{ github.event_name == 'pull_request' && github.base_ref != 'refs/heads/develop' && github.base_ref != 'refs/heads/master'}}
+      uses: actions/upload-artifact@v2
+      with:
+        name: stash-linux
+        path: dist/stash-linux
+        
+    - name: Update latest_develop tag
+      if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
+      run : git tag -f latest_develop; git push -f --tags
+
+    - name: Development Release
+      if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' }}      
+      uses: marvinpinto/action-automatic-releases@v1.1.2
+      with:
+        repo_token: "${{ secrets.GITHUB_TOKEN }}"
+        prerelease: true
+        automatic_release_tag: latest_develop
+        title: "${{ env.STASH_VERSION }}: Latest development build"
+        files: |
+          dist/stash-osx
+          dist/stash-win.exe
+          dist/stash-linux
+          dist/stash-linux-arm64v8
+          dist/stash-linux-arm32v7
+          dist/stash-pi
+          CHECKSUMS_SHA1
+        
+    - name: Master release
+      if: ${{ github.event_name == 'release' && github.ref != 'refs/tags/latest_develop' }}
+      uses: meeDamian/github-release@2.0
+      with:
+        token: "${{ secrets.GITHUB_TOKEN }}"
+        allow_override: true
+        files: |
+          dist/stash-osx
+          dist/stash-win.exe
+          dist/stash-linux
+          dist/stash-linux-arm64v8
+          dist/stash-linux-arm32v7
+          dist/stash-pi
+          CHECKSUMS_SHA1
+        gzip: false
+    
+    - name: Development Docker
+      if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
+      env:
+        DOCKER_CLI_EXPERIMENTAL: enabled
+        DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
+        DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
+      run: |
+        docker run --rm --privileged docker/binfmt:a7996909642ee92942dcd6cff44b9b95f08dad64  
+        docker info
+        docker buildx create --name builder --use
+        docker buildx inspect --bootstrap
+        docker buildx ls
+        bash ./docker/ci/x86_64/docker_push.sh development
+
+    - name: Release Docker
+      if: ${{ github.event_name == 'release' && github.ref != 'refs/tags/latest_develop' }}
+      env:
+        DOCKER_CLI_EXPERIMENTAL: enabled
+        DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
+        DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
+      run: |
+        docker run --rm --privileged docker/binfmt:a7996909642ee92942dcd6cff44b9b95f08dad64  
+        docker info
+        docker buildx create --name builder --use
+        docker buildx inspect --bootstrap
+        docker buildx ls
+        bash ./docker/ci/x86_64/docker_push.sh latest "${{ github.event.release.tag_name }}"

.gitignore

@@ -35,6 +35,7 @@ ui/v2.5/src/core/generated-*.tsx
 .idea/**/usage.statistics.xml
 .idea/**/dictionaries
 .idea/**/shelf
+.vscode
 
 # Generated files
 .idea/**/contentModel.xml

.travis.yml.disabled

@@ -12,6 +12,24 @@ env:
   global:
   - GO111MODULE=on
 before_install:
+  - set -e
+  # Configure environment so changes are picked up when the Docker daemon is restarted after upgrading
+  - echo '{"experimental":true}' | sudo tee /etc/docker/daemon.json
+  - export DOCKER_CLI_EXPERIMENTAL=enabled
+  # Upgrade to Docker CE 19.03 for BuildKit support
+  - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
+  - sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
+  - sudo apt-get update
+  - sudo apt-get -y -o Dpkg::Options::="--force-confnew" install docker-ce
+  # install binfmt docker container, this container uses qemu to run arm programs transparently allowng docker to build arm 6,7,8 containers.
+  - docker run --rm --privileged docker/binfmt:a7996909642ee92942dcd6cff44b9b95f08dad64
+  # Show info to simplify debugging and create a builder that can build the platforms we need
+  - docker info
+  - docker buildx create --name builder --use
+  - docker buildx inspect --bootstrap
+  - docker buildx ls
+
+install:
 - echo -e "machine github.com\n  login $CI_USER_TOKEN" > ~/.netrc
 - nvm install 12
 - travis_retry make pre-ui
@@ -25,6 +43,8 @@ script:
 after_success:
 - docker pull stashapp/compiler:4
 - sh ./scripts/cross-compile.sh
+- git describe --tags --exclude latest_develop | tee CHECKSUMS_SHA1
+- sha1sum dist/stash-* | sed 's/dist\///g' | tee -a CHECKSUMS_SHA1
 - 'if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then sh ./scripts/upload-pull-request.sh; fi'
 before_deploy:
 # push the latest tag when on the develop branch
@@ -47,6 +67,7 @@ deploy:
       - dist/stash-linux-arm64v8
       - dist/stash-linux-arm32v7
       - dist/stash-pi
+      - CHECKSUMS_SHA1
     skip_cleanup: true
     overwrite: true
     name: "${STASH_VERSION}: Latest development build"
@@ -58,7 +79,7 @@ deploy:
   # docker image build for develop release
   - provider: script
     skip_cleanup: true
-    script: bash ./docker/ci/x86_64/docker_push.sh development-x86_64
+    script: bash ./docker/ci/x86_64/docker_push.sh development
     on:
       repo: stashapp/stash
       branch: develop
@@ -73,6 +94,7 @@ deploy:
       - dist/stash-linux-arm64v8
       - dist/stash-linux-arm32v7
       - dist/stash-pi
+      - CHECKSUMS_SHA1
     # make the release a draft so the maintainers can confirm before releasing
     draft: true
     skip_cleanup: true

Makefile

@@ -22,6 +22,9 @@ ifdef OUTPUT
   OUTPUT := -o $(OUTPUT)
 endif
 
+export CGO_ENABLED = 1
+export GO111MODULE = on
+
 .PHONY: release pre-build install clean 
 
 release: generate ui build-release
@@ -41,7 +44,7 @@ endif
 
 build: pre-build
 	$(eval LDFLAGS := $(LDFLAGS) -X 'github.com/stashapp/stash/pkg/api.version=$(STASH_VERSION)' -X 'github.com/stashapp/stash/pkg/api.buildstamp=$(BUILD_DATE)' -X 'github.com/stashapp/stash/pkg/api.githash=$(GITHASH)')
-	$(SET) CGO_ENABLED=1 $(SEPARATOR) go build $(OUTPUT) -mod=vendor -v -tags "sqlite_omit_load_extension osusergo netgo" -ldflags "$(LDFLAGS) $(EXTRA_LDFLAGS)"
+	go build $(OUTPUT) -mod=vendor -v -tags "sqlite_omit_load_extension osusergo netgo" -ldflags "$(LDFLAGS) $(EXTRA_LDFLAGS)"
 
 # strips debug symbols from the release build
 # consider -trimpath in go build if we move to go 1.13+
@@ -51,6 +54,49 @@ build-release: build
 build-release-static: EXTRA_LDFLAGS := -extldflags=-static -s -w
 build-release-static: build
 
+# cross-compile- targets should be run within the compiler docker container
+cross-compile-windows: export GOOS := windows
+cross-compile-windows: export GOARCH := amd64
+cross-compile-windows: export CC := x86_64-w64-mingw32-gcc
+cross-compile-windows: export CXX := x86_64-w64-mingw32-g++
+cross-compile-windows: OUTPUT := -o dist/stash-win.exe
+cross-compile-windows: build-release-static
+
+cross-compile-osx: export GOOS := darwin
+cross-compile-osx: export GOARCH := amd64
+cross-compile-osx: export CC := o64-clang
+cross-compile-osx: export CXX := o64-clang++
+cross-compile-osx: OUTPUT := -o dist/stash-osx
+# can't use static build for OSX
+cross-compile-osx: build-release
+
+cross-compile-linux: export GOOS := linux
+cross-compile-linux: export GOARCH := amd64
+cross-compile-linux: OUTPUT := -o dist/stash-linux
+cross-compile-linux: build-release-static
+
+cross-compile-linux-arm64v8: export GOOS := linux
+cross-compile-linux-arm64v8: export GOARCH := arm64
+cross-compile-linux-arm64v8: export CC := aarch64-linux-gnu-gcc
+cross-compile-linux-arm64v8: OUTPUT := -o dist/stash-linux-arm64v8
+cross-compile-linux-arm64v8: build-release-static
+
+cross-compile-linux-arm32v7: export GOOS := linux
+cross-compile-linux-arm32v7: export GOARCH := arm
+cross-compile-linux-arm32v7: export GOARM := 7
+cross-compile-linux-arm32v7: export CC := arm-linux-gnueabihf-gcc
+cross-compile-linux-arm32v7: OUTPUT := -o dist/stash-linux-arm32v7
+cross-compile-linux-arm32v7: build-release-static
+
+cross-compile-pi: export GOOS := linux
+cross-compile-pi: export GOARCH := arm
+cross-compile-pi: export GOARM := 6
+cross-compile-pi: export CC := arm-linux-gnueabi-gcc
+cross-compile-pi: OUTPUT := -o dist/stash-pi
+cross-compile-pi: build-release-static
+
+cross-compile-all: cross-compile-windows cross-compile-osx cross-compile-linux cross-compile-linux-arm64v8 cross-compile-linux-arm32v7 cross-compile-pi
+
 install:
 	packr2 install
 

README.md

@@ -6,71 +6,94 @@
 
 https://stashapp.cc
 
-**Stash is a Go app which organizes and serves your porn.**
+**Stash is a locally hosted web-based app written in Go which organizes and serves your porn.**
 
-See a demo [here](https://vimeo.com/275537038) (password is stashapp).
+* It can gather information about videos in your collection from the internet, and is extensible through the use of community-built plugins for a large number of content producers.
+* It supports a wide variety of both video and image formats.
+* You can tag videos and find them later.
+* It provides statistics about performers, tags, studios and other things.
 
-An in-app manual is available, and the manual pages can be viewed [here](https://github.com/stashapp/stash/tree/develop/ui/v2.5/src/docs/en).
+You can [watch a SFW demo video](https://vimeo.com/545323354) to see it in action.
 
-# Docker install
+For further information you can [read the in-app manual](ui/v2.5/src/docs/en).
+
+# Installing stash
+
+## via Docker
 
 Follow [this README.md in the docker directory.](docker/production/README.md)
 
-# Bare-metal Install
+## Pre-Compiled Binaries
 
-Stash supports macOS, Windows, and Linux.  Download the [latest release here](https://github.com/stashapp/stash/releases).
+The Stash server runs on macOS, Windows, and Linux.  Download the [latest release here](https://github.com/stashapp/stash/releases).
 
 Run the executable (double click the exe on windows or run `./stash-osx` / `./stash-linux` from the terminal on macOS / Linux) and navigate to either https://localhost:9999 or http://localhost:9999 to get started.
 
-*Note for Windows users:* Running the app might present a security prompt since the binary isn't signed yet.  Just click more info and then the "run anyway" button.
+*Note for Windows users:* Running the app might present a security prompt since the binary isn't yet signed.  Bypass this by clicking "more info" and then the "run anyway" button.
 
 #### FFMPEG
 
 If stash is unable to find or download FFMPEG then download it yourself from the link for your platform:
 
-* [macOS](https://ffmpeg.zeranoe.com/builds/macos64/static/ffmpeg-4.0-macos64-static.zip)
-* [Windows](https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-4.0-win64-static.zip)
-* [Linux](https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz)
+* [macOS ffmpeg](https://evermeet.cx/ffmpeg/ffmpeg-4.3.1.zip), [macOS ffprobe](https://evermeet.cx/ffmpeg/ffprobe-4.3.1.zip)
+* [Windows](https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip)
+* [Linux](https://www.johnvansickle.com/ffmpeg/)
 
 The `ffmpeg(.exe)` and `ffprobe(.exe)` files should be placed in `~/.stash` on macOS / Linux or `C:\Users\YourUsername\.stash` on Windows.
 
 # Usage
 
+## Quickstart Guide
+1) Download and install Stash and its dependencies
+2) Run Stash. It will prompt you for some configuration options and a directory to index (you can also do this step afterward)
+3) After configuration, launch your web browser and navigate to the URL shown within the Stash app.
+
+**Note that Stash does not currently retrieve and organize information about your entire library automatically.**  You will need to help it along through the use of [scrapers](blob/develop/ui/v2.5/src/docs/en/Scraping.md).  The Stash community has developed scrapers for many popular data sources which can be downloaded and installed from [this repository](https://github.com/stashapp/CommunityScrapers).
+
+The simplest way to tag a large number of files is by using the [Tagger](https://github.com/stashapp/stash/blob/develop/ui/v2.5/src/docs/en/Tagger.md) which uses filename keywords to help identify the file and pull in scene and performer information from our stash-box database. Note that this data source is not comprehensive and you may need to use the scrapers to identify some of your media.
+
 ## CLI
 
-Stash provides some command line options.  See what is currently available by running `stash --help`.
+Stash runs as a command-line app and local web server.  There are some command-line options available, which you can see by running `stash --help`.
 
 For example, to run stash locally on port 80 run it like this (OSX / Linux) `stash --host 127.0.0.1 --port 80`
 
 ## SSL (HTTPS)
 
-Stash supports HTTPS with some additional work.  First you must generate a SSL certificate and key combo.  Here is an example using openssl:
+Stash can run over HTTPS with some additional work.  First you must generate a SSL certificate and key combo.  Here is an example using openssl:
 
 `openssl req -x509 -newkey rsa:4096 -sha256 -days 7300 -nodes -keyout stash.key -out stash.crt -extensions san -config <(echo "[req]"; echo distinguished_name=req; echo "[san]"; echo subjectAltName=DNS:stash.server,IP:127.0.0.1) -subj /CN=stash.server`
 
 This command would need customizing for your environment.  [This link](https://stackoverflow.com/questions/10175812/how-to-create-a-self-signed-certificate-with-openssl) might be useful.
 
-Once you have a certificate and key file name them `stash.crt` and `stash.key` and place them in the `~/.stash` directory.  Stash detects these and starts up using HTTPS rather than HTTP.
+Once you have a certificate and key file name them `stash.crt` and `stash.key` and place them in the same directory as the `config.yml` file, or the `~/.stash` directory.  Stash detects these and starts up using HTTPS rather than HTTP.
 
-# FAQ
+# Customization
 
-> I'm unable to run the app on OSX or Linux
+## Themes and CSS Customization
+There is a [directory of community-created themes](https://github.com/stashapp/stash/wiki/Themes) on our Wiki, along with instructions on how to install them.
 
-Try running `chmod u+x stash-osx` or `chmod u+x stash-linux` to make the file executable.
+You can also make Stash interface fit your desired style with [Custom CSS snippets](https://github.com/stashapp/stash/wiki/Custom-CSS-snippets) and [CSS Tweaks](https://github.com/stashapp/stash/wiki/CSS-Tweaks).
 
-> I have a question not answered here.
+# Support (FAQ)
 
-Join the [Discord server](https://discord.gg/2TsNFKt).
+Answers to other Frequently Asked Questions can be found [on our Wiki](https://github.com/stashapp/stash/wiki/FAQ)
 
-# Development
+For issues not addressed there, there are a few options.
 
-## Install
+* Read the [Wiki](https://github.com/stashapp/stash/wiki)
+* Check the in-app documentation (also available [here](https://github.com/stashapp/stash/tree/develop/ui/v2.5/src/docs/en)
+* Join the [Discord server](https://discord.gg/2TsNFKt), where the community can offer support.
+
+# Compiling From Source Code
+
+## Pre-requisites
 
 * [Go](https://golang.org/dl/)
 * [Revive](https://github.com/mgechev/revive) - Configurable linter
     * Go Install: `go get github.com/mgechev/revive`
-* [Packr2](https://github.com/gobuffalo/packr/tree/v2.0.2/v2) - Static asset bundler
-    * Go Install: `go get github.com/gobuffalo/packr/v2/packr2@v2.0.2`
+* [Packr2](https://github.com/gobuffalo/packr/) - Static asset bundler
+    * Go Install: `go get github.com/gobuffalo/packr/v2/packr2`
     * [Binary Download](https://github.com/gobuffalo/packr/releases)
 * [Yarn](https://yarnpkg.com/en/docs/install) - Yarn package manager
     * Run `yarn install --frozen-lockfile` in the `stash/ui/v2.5` folder (before running make generate for first time).
@@ -108,6 +131,7 @@ NOTE: The `make` command in Windows will be `mingw32-make` with MingW.
 * `make fmt-check` - Ensure changed files are formatted correctly
 * `make it` - Run the unit and integration tests
 * `make validate` - Run all of the tests and checks required to submit a PR
+* `make ui-start` - Runs the UI in development mode. Requires a running stash server to connect to. Stash port can be changed from the default of `9999` with environment variable `REACT_APP_PLATFORM_PORT`.
 
 ## Building a release
 
@@ -117,15 +141,20 @@ NOTE: The `make` command in Windows will be `mingw32-make` with MingW.
 
 ## Cross compiling
 
-This project uses a modification of [this](https://github.com/bep/dockerfiles/tree/master/ci-goreleaser) docker container to create an environment
+This project uses a modification of the [CI-GoReleaser](https://github.com/bep/dockerfiles/tree/master/ci-goreleaser) docker container to create an environment
 where the app can be cross-compiled.  This process is kicked off by CI via the `scripts/cross-compile.sh` script.  Run the following
 command to open a bash shell to the container to poke around:
 
 `docker run --rm --mount type=bind,source="$(pwd)",target=/stash -w /stash -i -t stashappdev/compiler:latest /bin/bash`
 
-## Customization
+## Profiling
 
-You can make Stash interface fit your desired style with  [Custom CSS snippets](https://github.com/stashapp/stash/wiki/Custom-CSS-snippets) and [CSS Tweaks](https://github.com/stashapp/stash/wiki/CSS-Tweaks).
+Stash can be profiled using the `--cpuprofile <output profile filename>` command line flag.
 
-[Stash Plex Theme](https://github.com/stashapp/stash/wiki/Stash-Plex-Theme) is a community created theme inspired by popular Plex Interface.
+The resulting file can then be used with pprof as follows: 
 
+`go tool pprof <path to binary> <path to profile filename>`
+
+With `graphviz` installed and in the path, a call graph can be generated with:
+
+`go tool pprof -svg <path to binary> <path to profile filename> > <output svg file>`

docker/build/x86_64/Dockerfile

@@ -53,6 +53,8 @@ FROM ubuntu:20.04 as app
 RUN apt-get update && apt-get -y install ca-certificates
 COPY --from=compiler /stash/stash /ffmpeg/ffmpeg /ffmpeg/ffprobe /usr/bin/
 
+ENV STASH_CONFIG_FILE=/root/.stash/config.yml
+
 EXPOSE 9999
 CMD ["stash"]
 

docker/ci/x86_64/Dockerfile

@@ -1,25 +1,22 @@
-
-# must be built from /dist directory
-
-FROM ubuntu:20.04 as prep
-LABEL MAINTAINER="https://discord.gg/Uz29ny"
-
-RUN apt-get update && \
-    apt-get -y install curl xz-utils && \
-    apt-get autoclean -y && \
-    rm -rf /var/lib/apt/lists/*
+FROM --platform=$BUILDPLATFORM ubuntu:20.04  AS prep
+ARG TARGETPLATFORM
 WORKDIR /
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-RUN curl --http1.1 -o /ffmpeg.tar.xz https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz && \
-    tar xf /ffmpeg.tar.xz && \
-    rm ffmpeg.tar.xz && \
-    mv /ffmpeg*/ /ffmpeg/
-
+COPY stash-*  /
+RUN if [ "$TARGETPLATFORM" = "linux/arm/v6" ];   then BIN=stash-pi; \
+    elif [ "$TARGETPLATFORM" = "linux/arm/v7" ]; then BIN=stash-linux-arm32v7; \
+    elif [ "$TARGETPLATFORM" = "linux/arm64" ];  then BIN=stash-linux-arm64v8; \
+    elif [ "$TARGETPLATFORM" = "linux/amd64" ];  then BIN=stash-linux; \
+    fi; \
+    mv $BIN /stash
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt update && apt install -y python3 python-is-python3 python3-requests python3-requests-toolbelt python3-lxml python3-pip && pip3 install cloudscraper
 FROM ubuntu:20.04 as app
-RUN apt-get update && apt-get -y install ca-certificates
-COPY --from=prep /ffmpeg/ffmpeg /ffmpeg/ffprobe /usr/bin/
-COPY /stash-linux /usr/bin/stash
+run apt update && apt install -y python3 python-is-python3 python3-requests python3-requests-toolbelt python3-lxml python3-mechanicalsoup ffmpeg && rm -rf /var/lib/apt/lists/*
+COPY --from=prep /stash /usr/bin/
+COPY --from=prep /usr/local/lib/python3.8/dist-packages /usr/local/lib/python3.8/dist-packages
+
+ENV STASH_CONFIG_FILE=/root/.stash/config.yml
 
 EXPOSE 9999
 CMD ["stash"]
+

docker/ci/x86_64/docker_push.sh

@@ -1,9 +1,14 @@
 #!/bin/bash
 
-DOCKER_TAG=$1
+DOCKER_TAGS=""
 
-# must build the image from dist directory
-docker build -t stashapp/stash:$DOCKER_TAG -f ./docker/ci/x86_64/Dockerfile ./dist
+for TAG in "$@"
+do
+	DOCKER_TAGS="$DOCKER_TAGS -t stashapp/stash:$TAG"
+done
 
 echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
-docker push stashapp/stash:$DOCKER_TAG
+
+# must build the image from dist directory
+docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 --push $DOCKER_TAGS -f docker/ci/x86_64/Dockerfile dist/
+

docker/develop/x86_64/Dockerfile

@@ -20,5 +20,8 @@ RUN curl --http1.1 -o /ffmpeg.tar.xz https://johnvansickle.com/ffmpeg/releases/f
 FROM ubuntu:20.04 as app
 RUN apt-get update && apt-get -y install ca-certificates
 COPY --from=prep /stash /ffmpeg/ffmpeg /ffmpeg/ffprobe /usr/bin/
+
+ENV STASH_CONFIG_FILE=/root/.stash/config.yml
+
 EXPOSE 9999
 CMD ["stash"]

docker/production/x86_64/Dockerfile

@@ -20,5 +20,8 @@ RUN curl --http1.1 -o /ffmpeg.tar.xz https://johnvansickle.com/ffmpeg/releases/f
 FROM ubuntu:20.04 as app
 RUN apt-get update && apt-get -y install ca-certificates
 COPY --from=prep /stash /ffmpeg/ffmpeg /ffmpeg/ffprobe /usr/bin/
+
+ENV STASH_CONFIG_FILE=/root/.stash/config.yml
+
 EXPOSE 9999
 CMD ["stash"]

go.mod

@@ -3,13 +3,17 @@ module github.com/stashapp/stash
 require (
 	github.com/99designs/gqlgen v0.12.2
 	github.com/Yamashou/gqlgenc v0.0.0-20200902035953-4dbef3551953
+	github.com/anacrolix/dms v1.2.2
 	github.com/antchfx/htmlquery v1.2.3
-	github.com/bmatcuk/doublestar/v2 v2.0.1
-	github.com/chromedp/cdproto v0.0.0-20200608134039-8a80cdaf865c
-	github.com/chromedp/chromedp v0.5.3
+	github.com/chromedp/cdproto v0.0.0-20210622022015-fe1827b46b84
+	github.com/chromedp/chromedp v0.7.3
+	github.com/corona10/goimagehash v1.0.3
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/disintegration/imaging v1.6.0
+	github.com/fvbommel/sortorder v1.0.2
 	github.com/go-chi/chi v4.0.2+incompatible
-	github.com/gobuffalo/packr/v2 v2.0.2
+	github.com/gobuffalo/logger v1.0.4 // indirect
+	github.com/gobuffalo/packr/v2 v2.8.1
 	github.com/golang-migrate/migrate/v4 v4.3.1
 	github.com/gorilla/securecookie v1.1.1
 	github.com/gorilla/sessions v1.2.0
@@ -18,21 +22,29 @@ require (
 	github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a
 	github.com/jmoiron/sqlx v1.2.0
 	github.com/json-iterator/go v1.1.9
-	github.com/mattn/go-sqlite3 v1.13.0
+	github.com/karrick/godirwalk v1.16.1 // indirect
+	github.com/mattn/go-sqlite3 v1.14.6
 	github.com/natefinch/pie v0.0.0-20170715172608-9a0d72014007
+	github.com/remeh/sizedwaitgroup v1.0.0
+	github.com/robertkrimen/otto v0.0.0-20200922221731-ef014fd054ac
 	github.com/rs/cors v1.6.0
 	github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f
-	github.com/sirupsen/logrus v1.4.2
+	github.com/sirupsen/logrus v1.8.1
+	github.com/spf13/afero v1.2.0 // indirect
 	github.com/spf13/pflag v1.0.3
 	github.com/spf13/viper v1.7.0
 	github.com/stretchr/testify v1.5.1
-	github.com/tidwall/gjson v1.6.0
+	github.com/tidwall/gjson v1.8.1
+	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/vektah/gqlparser/v2 v2.0.1
 	github.com/vektra/mockery/v2 v2.2.1
-	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
-	golang.org/x/image v0.0.0-20190802002840-cff245a6509b
-	golang.org/x/net v0.0.0-20200822124328-c89045814202
+	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97
+	golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb
+	golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
+	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c
+	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
 	golang.org/x/tools v0.0.0-20200915031644-64986481280e // indirect
+	gopkg.in/sourcemap.v1 v1.0.5 // indirect
 	gopkg.in/yaml.v2 v2.3.0
 )
 

gqlgen.yml

@@ -52,5 +52,7 @@ models:
     model: github.com/stashapp/stash/pkg/models.ScrapedMovie
   ScrapedMovieStudio:
     model: github.com/stashapp/stash/pkg/models.ScrapedMovieStudio
+  SavedFilter:
+    model: github.com/stashapp/stash/pkg/models.SavedFilter
   StashID:
     model: github.com/stashapp/stash/pkg/models.StashID

graphql/documents/data/config.graphql

@@ -2,13 +2,15 @@ fragment ConfigGeneralData on ConfigGeneralResult {
   stashes {
     path
     excludeVideo
-    excludeImage 
+    excludeImage
   }
   databasePath
   generatedPath
   cachePath
   calculateMD5
   videoFileNamingAlgorithm
+  parallelTasks
+  previewAudio
   previewSegments
   previewSegmentDuration
   previewExcludeStart
@@ -16,6 +18,7 @@ fragment ConfigGeneralData on ConfigGeneralResult {
   previewPreset
   maxTranscodeSize
   maxStreamingTranscodeSize
+  apiKey
   username
   password
   maxSessionAge
@@ -29,7 +32,9 @@ fragment ConfigGeneralData on ConfigGeneralResult {
   galleryExtensions
   excludes
   imageExcludes
+  customPerformerImageLocation
   scraperUserAgent
+  scraperCertCheck
   scraperCDPPath
   stashBoxes {
     name
@@ -39,6 +44,7 @@ fragment ConfigGeneralData on ConfigGeneralResult {
 }
 
 fragment ConfigInterfaceData on ConfigInterfaceResult {
+  menuItems
   soundOnPreview
   wallShowTitle
   wallPlayback
@@ -48,6 +54,23 @@ fragment ConfigInterfaceData on ConfigInterfaceResult {
   css
   cssEnabled
   language
+  slideshowDelay
+  handyKey
+  funscriptOffset
+}
+
+fragment ConfigDLNAData on ConfigDLNAResult {
+  serverName
+  enabled
+  whitelistedIPs
+  interfaces
+}
+
+fragment ConfigScrapingData on ConfigScrapingResult {
+  scraperUserAgent
+  scraperCertCheck
+  scraperCDPPath
+  excludeTagPatterns
 }
 
 fragment ConfigData on ConfigResult {
@@ -57,4 +80,10 @@ fragment ConfigData on ConfigResult {
   interface {
     ...ConfigInterfaceData
   }
+  dlna {
+    ...ConfigDLNAData
+  }
+  scraping {
+    ...ConfigScrapingData
+  }
 }

graphql/documents/data/filter.graphql

@@ -0,0 +1,6 @@
+fragment SavedFilterData on SavedFilter {
+  id
+  mode
+  name
+  filter
+}

graphql/documents/data/gallery-slim.graphql

@@ -1,4 +1,4 @@
-fragment GallerySlimData on Gallery {
+fragment SlimGalleryData on Gallery {
   id
   checksum
   path
@@ -7,20 +7,36 @@ fragment GallerySlimData on Gallery {
   url
   details
   rating
+  organized
   image_count
   cover {
-    ...SlimImageData
+    file {
+      size
+      width
+      height
+    }
+    
+    paths {
+      thumbnail
+    }
   }
   studio {
-    ...StudioData
+    id
+    name
+    image_path
   }
   tags {
-    ...TagData
+    id
+    name
   }
   performers {
-    ...PerformerData
+    id
+    name
+    gender
+    favorite
+    image_path
   }
-  scene {
+  scenes {
     id
     title
     path

graphql/documents/data/gallery.graphql

@@ -7,6 +7,7 @@ fragment GalleryData on Gallery {
   url
   details
   rating
+  organized
   images {
     ...SlimImageData
   }
@@ -14,18 +15,16 @@ fragment GalleryData on Gallery {
     ...SlimImageData
   }
   studio {
-    ...StudioData
+    ...SlimStudioData
   }
   tags {
-    ...TagData
+    ...SlimTagData
   }
 
   performers {
     ...PerformerData
   }
-  scene {
-    id
-    title
-    path
+  scenes {
+    ...SlimSceneData
   }
 }

graphql/documents/data/image-slim.graphql

@@ -3,6 +3,7 @@ fragment SlimImageData on Image {
   checksum
   title
   rating
+  organized
   o_counter
   path
 
@@ -37,6 +38,7 @@ fragment SlimImageData on Image {
   performers {
     id
     name
+    gender
     favorite
     image_path
   }

graphql/documents/data/image.graphql

@@ -3,6 +3,7 @@ fragment ImageData on Image {
   checksum
   title
   rating
+  organized
   o_counter
   path
 
@@ -22,11 +23,11 @@ fragment ImageData on Image {
   }
 
   studio {
-    ...StudioData
+    ...SlimStudioData
   }
   
   tags {
-    ...TagData
+    ...SlimTagData
   }
 
   performers {

graphql/documents/data/job.graphql

@@ -0,0 +1,10 @@
+fragment JobData on Job {
+  id
+  status
+  subTasks
+  description
+  progress
+  startTime
+  endTime
+  addTime
+}

graphql/documents/data/movie.graphql

@@ -9,7 +9,7 @@ fragment MovieData on Movie {
   director
 
   studio {
-    ...StudioData
+    ...SlimStudioData
   }
   
   synopsis

graphql/documents/data/performer-slim.graphql

@@ -3,8 +3,14 @@ fragment SlimPerformerData on Performer {
   name
   gender
   image_path
+  favorite
+  tags {
+    id
+    name
+  }
   stash_ids {
     endpoint
     stash_id
   }
+  rating
 }

graphql/documents/data/performer.graphql

@@ -20,8 +20,20 @@ fragment PerformerData on Performer {
   favorite
   image_path
   scene_count
+  image_count
+  gallery_count
+
+  tags {
+    ...SlimTagData
+  }
+
   stash_ids {
     stash_id
     endpoint
   }
+  rating
+  details
+  death_date
+  hair_color
+  weight
 }

graphql/documents/data/scene-marker.graphql

@@ -12,10 +12,12 @@ fragment SceneMarkerData on SceneMarker {
   primary_tag {
     id
     name
+    aliases
   }
 
   tags {
     id
     name
+    aliases
   }
 }

graphql/documents/data/scene-slim.graphql

@@ -8,7 +8,10 @@ fragment SlimSceneData on Scene {
   date
   rating
   o_counter
+  organized
   path
+  phash
+  interactive
 
   file {
     size
@@ -28,6 +31,8 @@ fragment SlimSceneData on Scene {
     webp
     vtt
     chapters_vtt
+    sprite
+    funscript
   }
 
   scene_markers {
@@ -36,7 +41,7 @@ fragment SlimSceneData on Scene {
     seconds
   }
 
-  gallery {
+  galleries {
     id
     path
     title
@@ -65,6 +70,7 @@ fragment SlimSceneData on Scene {
   performers {
     id
     name
+    gender
     favorite
     image_path
   }

graphql/documents/data/scene.graphql

@@ -8,7 +8,10 @@ fragment SceneData on Scene {
   date
   rating
   o_counter
+  organized
   path
+  phash
+  interactive
 
   file {
     size
@@ -28,18 +31,20 @@ fragment SceneData on Scene {
     webp
     vtt
     chapters_vtt
+    sprite
+    funscript
   }
 
   scene_markers {
     ...SceneMarkerData
   }
 
-  gallery {
-    ...GalleryData
+  galleries {
+    ...SlimGalleryData
   }
 
   studio {
-    ...StudioData
+    ...SlimStudioData
   }
   
   movies {
@@ -50,7 +55,7 @@ fragment SceneData on Scene {
   }
 
   tags {
-    ...TagData
+    ...SlimTagData
   }
 
   performers {

graphql/documents/data/scrapers.graphql

@@ -15,7 +15,15 @@ fragment ScrapedPerformerData on ScrapedPerformer {
   tattoos
   piercings
   aliases
+  tags {
+    ...ScrapedSceneTagData
+  }
   image
+  details
+  death_date
+  hair_color
+  weight
+  remote_site_id
 }
 
 fragment ScrapedScenePerformerData on ScrapedScenePerformer {
@@ -36,8 +44,15 @@ fragment ScrapedScenePerformerData on ScrapedScenePerformer {
   tattoos
   piercings
   aliases
+  tags {
+    ...ScrapedSceneTagData
+  }
   remote_site_id
   images
+  details
+  death_date
+  hair_color
+  weight
 }
 
 fragment ScrapedMovieStudioData on ScrapedMovieStudio {
@@ -183,3 +198,10 @@ fragment ScrapedStashBoxSceneData on ScrapedScene {
     ...ScrapedSceneMovieData
   }
 }
+
+fragment ScrapedStashBoxPerformerData on StashBoxPerformerQueryResult {
+  query
+  results {
+    ...ScrapedScenePerformerData
+  }
+}

graphql/documents/data/studio-slim.graphql

@@ -9,4 +9,6 @@ fragment SlimStudioData on Studio {
   parent_studio {
     id
   }
+  details
+  rating
 }

graphql/documents/data/studio.graphql

@@ -5,24 +5,23 @@ fragment StudioData on Studio {
   url
   parent_studio {
     id
-    checksum
     name
     url
     image_path
-    scene_count
   }
   child_studios {
     id
-    checksum
     name
-    url
     image_path
-    scene_count
   }
   image_path
   scene_count
+  image_count
+  gallery_count
   stash_ids {
     stash_id
     endpoint
   }
+  details
+  rating
 }

graphql/documents/data/tag-slim.graphql

@@ -0,0 +1,6 @@
+fragment SlimTagData on Tag {
+  id
+  name
+  aliases
+  image_path
+}

graphql/documents/data/tag.graphql

@@ -1,7 +1,11 @@
 fragment TagData on Tag {
   id
   name
+  aliases
   image_path
   scene_count
   scene_marker_count
+  image_count
+  gallery_count
+  performer_count
 }

graphql/documents/mutations/config.graphql

@@ -1,3 +1,11 @@
+mutation Setup($input: SetupInput!) {
+  setup(input: $input)
+}
+
+mutation Migrate($input: MigrateInput!) {
+  migrate(input: $input)
+}
+
 mutation ConfigureGeneral($input: ConfigGeneralInput!) {
   configureGeneral(input: $input) {
     ...ConfigGeneralData
@@ -8,4 +16,20 @@ mutation ConfigureInterface($input: ConfigInterfaceInput!) {
   configureInterface(input: $input) {
     ...ConfigInterfaceData
   }
-}
+}
+
+mutation ConfigureDLNA($input: ConfigDLNAInput!) {
+  configureDLNA(input: $input) {
+    ...ConfigDLNAData
+  }
+}
+
+mutation ConfigureScraping($input: ConfigScrapingInput!) {
+  configureScraping(input: $input) {
+    ...ConfigScrapingData
+  }
+}
+
+mutation GenerateAPIKey($input: GenerateAPIKeyInput!) {
+  generateAPIKey(input: $input)
+}

graphql/documents/mutations/dlna.graphql

@@ -0,0 +1,15 @@
+mutation EnableDLNA($input: EnableDLNAInput!) {
+  enableDLNA(input: $input)
+}
+
+mutation DisableDLNA($input: DisableDLNAInput!) {
+  disableDLNA(input: $input)
+}
+
+mutation AddTempDLNAIP($input: AddTempDLNAIPInput!) {
+  addTempDLNAIP(input: $input)
+}
+
+mutation RemoveTempDLNAIP($input: RemoveTempDLNAIPInput!) {
+  removeTempDLNAIP(input: $input)
+}

graphql/documents/mutations/filter.graphql

@@ -0,0 +1,13 @@
+mutation SaveFilter($input: SaveFilterInput!) {
+  saveFilter(input: $input) {
+    ...SavedFilterData
+  }
+} 
+
+mutation DestroySavedFilter($input: DestroyFilterInput!) {
+  destroySavedFilter(input: $input)
+}
+
+mutation SetDefaultFilter($input: SetDefaultFilterInput!) {
+  setDefaultFilter(input: $input)
+}

graphql/documents/mutations/gallery.graphql

@@ -1,79 +1,23 @@
 mutation GalleryCreate(
-  $title: String!,
-  $details: String,
-  $url: String,
-  $date: String,
-  $rating: Int,
-  $scene_id: ID,
-  $studio_id: ID,
-  $performer_ids: [ID!] = [],
-  $tag_ids: [ID!] = []) {
+  $input: GalleryCreateInput!) {
 
-  galleryCreate(input: {
-    title: $title,
-    details: $details,
-    url: $url,
-    date: $date,
-    rating: $rating,
-    scene_id: $scene_id,
-    studio_id: $studio_id,
-    tag_ids: $tag_ids,
-    performer_ids: $performer_ids
-    }) {
+  galleryCreate(input: $input) {
       ...GalleryData
   }
 }
 
 mutation GalleryUpdate(
-  $id: ID!,
-  $title: String,
-  $details: String,
-  $url: String,
-  $date: String,
-  $rating: Int,
-  $scene_id: ID,
-  $studio_id: ID,
-  $performer_ids: [ID!] = [],
-  $tag_ids: [ID!] = []) {
+  $input: GalleryUpdateInput!) {
 
-  galleryUpdate(input: {
-                        id: $id,
-                        title: $title,
-                        details: $details,
-                        url: $url,
-                        date: $date,
-                        rating: $rating,
-                        scene_id: $scene_id,
-                        studio_id: $studio_id,
-                        tag_ids: $tag_ids,
-                        performer_ids: $performer_ids
-                      }) {
+  galleryUpdate(input: $input) {
       ...GalleryData
   }
 }
 
 mutation BulkGalleryUpdate(
-  $ids: [ID!] = [],
-  $url: String,
-  $date: String,
-  $details: String,
-  $rating: Int,
-  $scene_id: ID,
-  $studio_id: ID,
-  $tag_ids: BulkUpdateIds,
-  $performer_ids: BulkUpdateIds) {
+  $input: BulkGalleryUpdateInput!) {
 
-  bulkGalleryUpdate(input: {
-                        ids: $ids,
-                        details: $details,
-                        url: $url,
-                        date: $date,
-                        rating: $rating,
-                        scene_id: $scene_id,
-                        studio_id: $studio_id,
-                        tag_ids: $tag_ids,
-                        performer_ids: $performer_ids
-                      }) {
+  bulkGalleryUpdate(input: $input) {
       ...GalleryData
   }
 }

graphql/documents/mutations/image.graphql

@@ -1,43 +1,15 @@
 mutation ImageUpdate(
-  $id: ID!,
-  $title: String,
-  $rating: Int,
-  $studio_id: ID,
-  $gallery_ids: [ID!] = [],
-  $performer_ids: [ID!] = [],
-  $tag_ids: [ID!] = []) {
+  $input: ImageUpdateInput!) {
 
-  imageUpdate(input: {
-                        id: $id,
-                        title: $title,
-                        rating: $rating,
-                        studio_id: $studio_id,
-                        gallery_ids: $gallery_ids,
-                        performer_ids: $performer_ids,
-                        tag_ids: $tag_ids
-                      }) {
+  imageUpdate(input: $input) {
       ...SlimImageData
   }
 }
 
 mutation BulkImageUpdate(
-  $ids: [ID!] = [],
-  $title: String,
-  $rating: Int,
-  $studio_id: ID,
-  $gallery_ids: BulkUpdateIds,
-  $performer_ids: BulkUpdateIds,
-  $tag_ids: BulkUpdateIds) {
+  $input: BulkImageUpdateInput!) {
 
-  bulkImageUpdate(input: {
-                        ids: $ids,
-                        title: $title,
-                        rating: $rating,
-                        studio_id: $studio_id,
-                        gallery_ids: $gallery_ids,
-                        performer_ids: $performer_ids,
-                        tag_ids: $tag_ids
-                      }) {
+  bulkImageUpdate(input: $input) {
       ...SlimImageData
   }
 }

graphql/documents/mutations/job.graphql

@@ -0,0 +1,7 @@
+mutation StopJob($job_id: ID!) {
+  stopJob(job_id: $job_id)
+}
+
+mutation StopAllJobs {
+    stopAllJobs
+}

graphql/documents/mutations/metadata.graphql

@@ -26,14 +26,14 @@ mutation MetadataAutoTag($input: AutoTagMetadataInput!) {
   metadataAutoTag(input: $input)
 }
 
-mutation MetadataClean {
-  metadataClean
+mutation MetadataClean($input: CleanMetadataInput!) {
+  metadataClean(input: $input)
 }
 
 mutation MigrateHashNaming {
   migrateHashNaming
 }
 
-mutation StopJob {
-  stopJob
-}
+mutation BackupDatabase($input: BackupDatabaseInput!) {
+  backupDatabase(input: $input)
+}

graphql/documents/mutations/movie.graphql

@@ -16,25 +16,16 @@ mutation MovieCreate(
   }
 }
 
-mutation MovieUpdate(
-  $id: ID!
-  $name: String,
-  $aliases: String,
-  $duration: Int,
-  $date: String,
-  $rating: Int,
-  $studio_id: ID,
-  $director: String,
-  $synopsis: String,
-  $url: String,
-  $front_image: String,
-  $back_image: String) {
-
-  movieUpdate(input: { id: $id, name: $name, aliases: $aliases, duration: $duration, date: $date, rating: $rating, studio_id: $studio_id, director: $director, synopsis: $synopsis, url: $url, front_image: $front_image, back_image: $back_image }) {
+mutation MovieUpdate($input: MovieUpdateInput!) {
+  movieUpdate(input: $input) {
     ...MovieData
   }
 }
 
 mutation MovieDestroy($id: ID!) {
   movieDestroy(input: { id: $id })
-}
+}
+
+mutation MoviesDestroy($ids: [ID!]!) {
+  moviesDestroy(ids: $ids)
+}

graphql/documents/mutations/performer.graphql

@@ -1,93 +1,23 @@
 mutation PerformerCreate(
-  $name: String!,
-  $url: String,
-  $gender: GenderEnum,
-  $birthdate: String,
-  $ethnicity: String,
-  $country: String,
-  $eye_color: String,
-  $height: String,
-  $measurements: String,
-  $fake_tits: String,
-  $career_length: String,
-  $tattoos: String,
-  $piercings: String,
-  $aliases: String,
-  $twitter: String,
-  $instagram: String,
-  $favorite: Boolean,
-  $stash_ids: [StashIDInput!],
-  $image: String) {
+  $input: PerformerCreateInput!) {
 
-  performerCreate(input: {
-                            name: $name,
-                            url: $url,
-                            gender: $gender,
-                            birthdate: $birthdate,
-                            ethnicity: $ethnicity,
-                            country: $country,
-                            eye_color: $eye_color,
-                            height: $height,
-                            measurements: $measurements,
-                            fake_tits: $fake_tits,
-                            career_length: $career_length,
-                            tattoos: $tattoos,
-                            piercings: $piercings,
-                            aliases: $aliases,
-                            twitter: $twitter,
-                            instagram: $instagram,
-                            favorite: $favorite,
-                            stash_ids: $stash_ids,
-                            image: $image
-                          }) {
+  performerCreate(input: $input) {
       ...PerformerData
   }
 }
 
 mutation PerformerUpdate(
-  $id: ID!,
-  $name: String,
-  $url: String,
-  $gender: GenderEnum,
-  $birthdate: String,
-  $ethnicity: String,
-  $country: String,
-  $eye_color: String,
-  $height: String,
-  $measurements: String,
-  $fake_tits: String,
-  $career_length: String,
-  $tattoos: String,
-  $piercings: String,
-  $aliases: String,
-  $twitter: String,
-  $instagram: String,
-  $favorite: Boolean,
-  $stash_ids: [StashIDInput!],
-  $image: String) {
+  $input: PerformerUpdateInput!) {
 
-  performerUpdate(input: {
-                            id: $id,
-                            name: $name,
-                            url: $url,
-                            gender: $gender,
-                            birthdate: $birthdate,
-                            ethnicity: $ethnicity,
-                            country: $country,
-                            eye_color: $eye_color,
-                            height: $height,
-                            measurements: $measurements,
-                            fake_tits: $fake_tits,
-                            career_length: $career_length,
-                            tattoos: $tattoos,
-                            piercings: $piercings,
-                            aliases: $aliases,
-                            twitter: $twitter,
-                            instagram: $instagram,
-                            favorite: $favorite,
-                            stash_ids: $stash_ids,
-                            image: $image
-                          }) {
+  performerUpdate(input: $input) {
+    ...PerformerData
+  }
+}
+
+mutation BulkPerformerUpdate(
+  $input: BulkPerformerUpdateInput!) {
+
+  bulkPerformerUpdate(input: $input) {
     ...PerformerData
   }
 }
@@ -95,3 +25,7 @@ mutation PerformerUpdate(
 mutation PerformerDestroy($id: ID!) {
   performerDestroy(input: { id: $id })
 }
+
+mutation PerformersDestroy($ids: [ID!]!) {
+  performersDestroy(ids: $ids)
+}

graphql/documents/mutations/scene.graphql

@@ -1,62 +1,16 @@
 mutation SceneUpdate(
-  $id: ID!,
-  $title: String,
-  $details: String,
-  $url: String,
-  $date: String,
-  $rating: Int,
-  $studio_id: ID,
-  $gallery_id: ID,
-  $performer_ids: [ID!] = [],
-  $movies: [SceneMovieInput!] = [],
-  $tag_ids: [ID!] = [],
-  $stash_ids: [StashIDInput!],
-  $cover_image: String) {
+  $input: SceneUpdateInput!) {
 
-  sceneUpdate(input: {
-                        id: $id,
-                        title: $title,
-                        details: $details,
-                        url: $url,
-                        date: $date,
-                        rating: $rating,
-                        studio_id: $studio_id,
-                        gallery_id: $gallery_id,
-                        performer_ids: $performer_ids,
-                        movies: $movies,
-                        tag_ids: $tag_ids,
-                        stash_ids: $stash_ids,
-                        cover_image: $cover_image
-                      }) {
-      ...SceneData
+  sceneUpdate(input: $input) {
+    ...SceneData
   }
 }
 
 mutation BulkSceneUpdate(
-  $ids: [ID!] = [],
-  $title: String,
-  $details: String,
-  $url: String,
-  $date: String,
-  $rating: Int,
-  $studio_id: ID,
-  $gallery_id: ID,
-  $performer_ids: BulkUpdateIds,
-  $tag_ids: BulkUpdateIds) {
+  $input: BulkSceneUpdateInput!) {
 
-  bulkSceneUpdate(input: {
-                        ids: $ids,
-                        title: $title,
-                        details: $details,
-                        url: $url,
-                        date: $date,
-                        rating: $rating,
-                        studio_id: $studio_id,
-                        gallery_id: $gallery_id,
-                        performer_ids: $performer_ids,
-                        tag_ids: $tag_ids
-                      }) {
-      ...SceneData
+  bulkSceneUpdate(input: $input) {
+    ...SceneData
   }
 }
 

graphql/documents/mutations/stash-box.graphql

@@ -1,3 +1,7 @@
 mutation SubmitStashBoxFingerprints($input: StashBoxFingerprintSubmissionInput!) {
   submitStashBoxFingerprints(input: $input)
 }
+
+mutation StashBoxBatchPerformerTag($input: StashBoxBatchPerformerTagInput!) {
+  stashBoxBatchPerformerTag(input: $input)
+}

graphql/documents/mutations/studio.graphql

@@ -1,24 +1,11 @@
-mutation StudioCreate(
-  $name: String!,
-  $url: String,
-  $image: String,
-  $stash_ids: [StashIDInput!],
-  $parent_id: ID) {
-
-  studioCreate(input: { name: $name, url: $url, image: $image, stash_ids: $stash_ids, parent_id: $parent_id }) {
+mutation StudioCreate($input: StudioCreateInput!) {
+  studioCreate(input: $input) {
     ...StudioData
   }
 }
 
-mutation StudioUpdate(
-  $id: ID!
-  $name: String,
-  $url: String,
-  $image: String,
-  $stash_ids: [StashIDInput!],
-  $parent_id: ID) {
-
-  studioUpdate(input: { id: $id, name: $name, url: $url, image: $image, stash_ids: $stash_ids, parent_id: $parent_id }) {
+mutation StudioUpdate($input: StudioUpdateInput!) {
+  studioUpdate(input: $input) {
     ...StudioData
   }
 }
@@ -26,3 +13,7 @@ mutation StudioUpdate(
 mutation StudioDestroy($id: ID!) {
   studioDestroy(input: { id: $id })
 }
+
+mutation StudiosDestroy($ids: [ID!]!) {
+  studiosDestroy(ids: $ids)
+}

graphql/documents/mutations/tag.graphql

@@ -1,5 +1,5 @@
-mutation TagCreate($name: String!, $image: String) {
-  tagCreate(input: { name: $name, image: $image }) {
+mutation TagCreate($input: TagCreateInput!) {
+  tagCreate(input: $input) {
     ...TagData
   }
 }
@@ -8,8 +8,18 @@ mutation TagDestroy($id: ID!) {
   tagDestroy(input: { id: $id })
 }
 
-mutation TagUpdate($id: ID!, $name: String!, $image: String) {
-  tagUpdate(input: { id: $id, name: $name, image: $image }) {
+mutation TagsDestroy($ids: [ID!]!) {
+  tagsDestroy(ids: $ids)
+}
+
+mutation TagUpdate($input: TagUpdateInput!) {
+  tagUpdate(input: $input) {
     ...TagData
   }
-}
+}
+
+mutation TagsMerge($source: [ID!]!, $destination: ID!) {
+  tagsMerge(input: { source: $source, destination: $destination }) {
+    ...TagData
+  }
+}

graphql/documents/queries/dlna.graphql

@@ -0,0 +1,11 @@
+query DLNAStatus {
+  dlnaStatus {
+    running
+    until
+    recentIPAddresses
+    allowedIPAddresses {
+      ipAddress
+      until
+    }
+  }
+}

graphql/documents/queries/filter.graphql

@@ -0,0 +1,11 @@
+query FindSavedFilters($mode: FilterMode!) {
+  findSavedFilters(mode: $mode) {
+    ...SavedFilterData
+  }
+}
+
+query FindDefaultFilter($mode: FilterMode!) {
+  findDefaultFilter(mode: $mode) {
+    ...SavedFilterData
+  }
+}

graphql/documents/queries/gallery.graphql

@@ -2,7 +2,7 @@ query FindGalleries($filter: FindFilterType, $gallery_filter: GalleryFilterType)
   findGalleries(gallery_filter: $gallery_filter, filter: $filter) {
     count
     galleries {
-      ...GallerySlimData
+      ...SlimGalleryData
     }
   }
 }

graphql/documents/queries/job.graphql

@@ -0,0 +1,11 @@
+query JobQueue {
+  jobQueue {
+    ...JobData
+  }
+}
+
+query FindJob($input: FindJobInput!) {
+    findJob(input: $input) {
+        ...JobData
+    }
+}

graphql/documents/queries/misc.graphql

@@ -13,34 +13,27 @@ query AllTags {
 }
 
 query AllPerformersForFilter {
-  allPerformersSlim {
+  allPerformers {
     ...SlimPerformerData
   }
 }
 
 query AllStudiosForFilter {
-  allStudiosSlim {
+  allStudios {
     ...SlimStudioData
   }
 }
 query AllMoviesForFilter {
-  allMoviesSlim {
+  allMovies {
     ...SlimMovieData
   }
 }
 
 query AllTagsForFilter {
-  allTagsSlim {
+  allTags {
     id
     name
-  }
-}
-
-query ValidGalleriesForScene($scene_id: ID!) {
-  validGalleriesForScene(scene_id: $scene_id) {
-    id
-    path
-    title
+    aliases
   }
 }
 
@@ -48,6 +41,7 @@ query Stats {
   stats {
     scene_count,
     scenes_size,
+    scenes_duration,
     image_count,
     images_size,
     gallery_count,

graphql/documents/queries/plugins.graphql

@@ -10,6 +10,12 @@ query Plugins {
       name
       description
     }
+
+    hooks {
+      name
+      description
+      hooks
+    }
   }
 }
 

graphql/documents/queries/scene.graphql

@@ -16,6 +16,12 @@ query FindScenesByPathRegex($filter: FindFilterType) {
   }
 }
 
+query FindDuplicateScenes($distance: Int) {
+  findDuplicateScenes(distance: $distance) {
+    ...SlimSceneData
+  }
+}
+
 query FindScene($id: ID!, $checksum: String) {
   findScene(id: $id, checksum: $checksum) {
     ...SceneData
@@ -45,7 +51,7 @@ query ParseSceneFilenames($filter: FindFilterType!, $config: SceneParserInput!)
       date
       rating
       studio_id
-      gallery_id
+      gallery_ids
       movies {
         movie_id
       }

graphql/documents/queries/scrapers/freeones.graphql

@@ -15,6 +15,10 @@ query ScrapeFreeones($performer_name: String!) {
     tattoos
     piercings
     aliases
+    details
+    death_date
+    hair_color
+    weight
   }
 }
 

graphql/documents/queries/scrapers/scrapers.graphql

@@ -90,8 +90,14 @@ query ScrapeMovieURL($url: String!) {
   }
 }
 
-query QueryStashBoxScene($input: StashBoxQueryInput!) {
+query QueryStashBoxScene($input: StashBoxSceneQueryInput!) {
   queryStashBoxScene(input: $input) {
     ...ScrapedStashBoxSceneData
   }
 }
+
+query QueryStashBoxPerformer($input: StashBoxPerformerQueryInput!) {
+  queryStashBoxPerformer(input: $input) {
+    ...ScrapedStashBoxPerformerData
+  }
+}

graphql/documents/queries/settings/metadata.graphql

@@ -1,7 +1,9 @@
-query JobStatus {
-  jobStatus {
-    progress
+query SystemStatus {
+  systemStatus {
+    databaseSchema
+    databasePath
+    appSchema
     status
-    message
+    configPath
   }
 }

graphql/documents/subscriptions.graphql

@@ -1,8 +1,13 @@
-subscription MetadataUpdate {
-  metadataUpdate {
-    progress
-    status
-    message
+subscription JobsSubscribe {
+  jobsSubscribe {
+    type
+    job {
+      id
+      status
+      subTasks
+      description
+      progress
+    }
   }
 }
 
@@ -10,4 +15,8 @@ subscription LoggingSubscribe {
   loggingSubscribe {
     ...LogEntryData
   }
+}
+
+subscription ScanCompleteSubscribe {
+  scanCompleteSubscribe
 }

graphql/schema/schema.graphql

@@ -1,5 +1,9 @@
 """The query root for this schema"""
 type Query {
+  # Filters
+  findSavedFilters(mode: FilterMode!): [SavedFilter!]!
+  findDefaultFilter(mode: FilterMode!): SavedFilter
+
   """Find a scene by ID or Checksum"""
   findScene(id: ID, checksum: String): Scene
   findSceneByHash(input: SceneHashInput!): Scene
@@ -9,6 +13,9 @@ type Query {
 
   findScenesByPathRegex(filter: FindFilterType): FindScenesResultType!
 
+  """ Returns any groups of scenes that are perceptual duplicates within the queried distance """
+  findDuplicateScenes(distance: Int): [[Scene!]!]!
+
   """Return valid stream paths"""
   sceneStreams(id: ID): [SceneStreamEndpoint!]!
 
@@ -50,8 +57,6 @@ type Query {
 
   """Get marker strings"""
   markerStrings(q: String, sort: String): [MarkerStringsResultType]!
-  """Get the list of valid galleries for a given scene ID"""
-  validGalleriesForScene(scene_id: ID): [Gallery!]!
   """Get stats"""
   stats: StatsResultType!
   """Organize scene markers by tag for a given scene ID"""
@@ -90,7 +95,8 @@ type Query {
   scrapeFreeonesPerformerList(query: String!): [String!]!
 
   """Query StashBox for scenes"""
-  queryStashBoxScene(input: StashBoxQueryInput!): [ScrapedScene!]!
+  queryStashBoxScene(input: StashBoxSceneQueryInput!): [ScrapedScene!]!
+  queryStashBoxPerformer(input: StashBoxPerformerQueryInput!): [StashBoxPerformerQueryResult!]!
 
   # Plugins
   """List loaded plugins"""
@@ -104,9 +110,14 @@ type Query {
   """Returns an array of paths for the given path"""
   directory(path: String): Directory!
 
-  # Metadata
+  # System status
+  systemStatus: SystemStatus!
 
-  jobStatus: MetadataUpdateStatus!
+  # Job status
+  jobQueue: [Job!]
+  findJob(input: FindJobInput!): Job
+
+  dlnaStatus: DLNAStatus!
 
   # Get everything
 
@@ -117,11 +128,6 @@ type Query {
 
   # Get everything with minimal metadata
 
-  allPerformersSlim: [Performer!]!
-  allStudiosSlim: [Studio!]!
-  allMoviesSlim: [Movie!]!
-  allTagsSlim: [Tag!]!
-
   # Version
   version: Version!
   
@@ -130,6 +136,9 @@ type Query {
 }
 
 type Mutation {
+  setup(input: SetupInput!): Boolean!
+  migrate(input: MigrateInput!): Boolean!
+
   sceneUpdate(input: SceneUpdateInput!): Scene
   bulkSceneUpdate(input: BulkSceneUpdateInput!): [Scene!]
   sceneDestroy(input: SceneDestroyInput!): Boolean!
@@ -175,62 +184,96 @@ type Mutation {
   performerCreate(input: PerformerCreateInput!): Performer
   performerUpdate(input: PerformerUpdateInput!): Performer
   performerDestroy(input: PerformerDestroyInput!): Boolean!
+  performersDestroy(ids: [ID!]!): Boolean!
+  bulkPerformerUpdate(input: BulkPerformerUpdateInput!): [Performer!]
 
   studioCreate(input: StudioCreateInput!): Studio
   studioUpdate(input: StudioUpdateInput!): Studio
   studioDestroy(input: StudioDestroyInput!): Boolean!
+  studiosDestroy(ids: [ID!]!): Boolean!
 
   movieCreate(input: MovieCreateInput!): Movie
   movieUpdate(input: MovieUpdateInput!): Movie
   movieDestroy(input: MovieDestroyInput!): Boolean!
+  moviesDestroy(ids: [ID!]!): Boolean!
 
   tagCreate(input: TagCreateInput!): Tag
   tagUpdate(input: TagUpdateInput!): Tag
   tagDestroy(input: TagDestroyInput!): Boolean!
+  tagsDestroy(ids: [ID!]!): Boolean!
+  tagsMerge(input: TagsMergeInput!): Tag
+
+  # Saved filters
+  saveFilter(input: SaveFilterInput!): SavedFilter!
+  destroySavedFilter(input: DestroyFilterInput!): Boolean!
+  setDefaultFilter(input: SetDefaultFilterInput!): Boolean!
 
   """Change general configuration options"""
   configureGeneral(input: ConfigGeneralInput!): ConfigGeneralResult!
   configureInterface(input: ConfigInterfaceInput!): ConfigInterfaceResult!
+  configureDLNA(input: ConfigDLNAInput!): ConfigDLNAResult!
+  configureScraping(input: ConfigScrapingInput!): ConfigScrapingResult!
+
+  """Generate and set (or clear) API key"""
+  generateAPIKey(input: GenerateAPIKeyInput!): String!
 
   """Returns a link to download the result"""
   exportObjects(input: ExportObjectsInput!): String
 
   """Performs an incremental import. Returns the job ID"""
-  importObjects(input: ImportObjectsInput!): String!
+  importObjects(input: ImportObjectsInput!): ID!
 
   """Start an full import. Completely wipes the database and imports from the metadata directory. Returns the job ID"""
-  metadataImport: String!
+  metadataImport: ID!
   """Start a full export. Outputs to the metadata directory. Returns the job ID"""
-  metadataExport: String!
+  metadataExport: ID!
   """Start a scan. Returns the job ID"""
-  metadataScan(input: ScanMetadataInput!): String!
+  metadataScan(input: ScanMetadataInput!): ID!
   """Start generating content. Returns the job ID"""
-  metadataGenerate(input: GenerateMetadataInput!): String!
+  metadataGenerate(input: GenerateMetadataInput!): ID!
   """Start auto-tagging. Returns the job ID"""
-  metadataAutoTag(input: AutoTagMetadataInput!): String!
+  metadataAutoTag(input: AutoTagMetadataInput!): ID!
   """Clean metadata. Returns the job ID"""
-  metadataClean: String!
+  metadataClean(input: CleanMetadataInput!): ID!
   """Migrate generated files for the current hash naming"""
-  migrateHashNaming: String!
+  migrateHashNaming: ID!
 
   """Reload scrapers"""
   reloadScrapers: Boolean!
 
   """Run plugin task. Returns the job ID"""
-  runPluginTask(plugin_id: ID!, task_name: String!, args: [PluginArgInput!]): String!
+  runPluginTask(plugin_id: ID!, task_name: String!, args: [PluginArgInput!]): ID!
   reloadPlugins: Boolean!
 
-  stopJob: Boolean!
+  stopJob(job_id: ID!): Boolean!
+  stopAllJobs: Boolean!
 
-  """ Submit fingerprints to stash-box instance """
+  """Submit fingerprints to stash-box instance"""
   submitStashBoxFingerprints(input: StashBoxFingerprintSubmissionInput!): Boolean!
+
+  """Backup the database. Optionally returns a link to download the database file"""
+  backupDatabase(input: BackupDatabaseInput!): String
+
+  """Run batch performer tag task. Returns the job ID."""
+  stashBoxBatchPerformerTag(input: StashBoxBatchPerformerTagInput!): String!
+  
+  """Enables DLNA for an optional duration. Has no effect if DLNA is enabled by default"""
+  enableDLNA(input: EnableDLNAInput!): Boolean!
+  """Disables DLNA for an optional duration. Has no effect if DLNA is disabled by default"""
+  disableDLNA(input: DisableDLNAInput!): Boolean!
+  """Enables an IP address for DLNA for an optional duration"""
+  addTempDLNAIP(input: AddTempDLNAIPInput!): Boolean!
+  """Removes an IP address from the temporary DLNA whitelist"""
+  removeTempDLNAIP(input: RemoveTempDLNAIPInput!): Boolean!
 }
 
 type Subscription {
   """Update from the metadata manager"""
-  metadataUpdate: MetadataUpdateStatus!
+  jobsSubscribe: JobStatusUpdate!
 
   loggingSubscribe: [LogEntry!]!
+
+  scanCompleteSubscribe: Boolean!
 }
 
 schema {

graphql/schema/types/config.graphql

@@ -1,3 +1,13 @@
+input SetupInput {
+  """Empty to indicate $HOME/.stash/config.yml default"""
+  configLocation: String!
+  stashes: [StashConfigInput!]!
+  """Empty to indicate default"""
+  databaseFile: String!
+  """Empty to indicate default"""
+  generatedLocation: String!
+}
+
 enum StreamingResolutionEnum {
   "240p", LOW
   "480p", STANDARD
@@ -35,6 +45,10 @@ input ConfigGeneralInput {
   calculateMD5: Boolean!
   """Hash algorithm to use for generated file naming"""
   videoFileNamingAlgorithm: HashAlgorithm!
+  """Number of parallel tasks to start during scan/generate"""
+  parallelTasks: Int
+  """Include audio stream in previews"""
+  previewAudio: Boolean!
   """Number of segments in a preview file"""
   previewSegments: Int
   """Preview segment duration, in seconds"""
@@ -75,10 +89,14 @@ input ConfigGeneralInput {
   excludes: [String!]
   """Array of file regexp to exclude from Image Scans"""
   imageExcludes: [String!]
+  """Custom Performer Image Location"""
+  customPerformerImageLocation: String
   """Scraper user agent string"""
-  scraperUserAgent: String
+  scraperUserAgent: String @deprecated(reason: "use mutation ConfigureScraping(input: ConfigScrapingInput) instead")
   """Scraper CDP path. Path to chrome executable or remote address"""
-  scraperCDPPath: String
+  scraperCDPPath: String @deprecated(reason: "use mutation ConfigureScraping(input: ConfigScrapingInput) instead")
+  """Whether the scraper should check for invalid certificates"""
+  scraperCertCheck: Boolean @deprecated(reason: "use mutation ConfigureScraping(input: ConfigScrapingInput) instead")
   """Stash-box instances used for tagging"""
   stashBoxes: [StashBoxInput!]!
 }
@@ -90,12 +108,20 @@ type ConfigGeneralResult {
   databasePath: String!
   """Path to generated files"""
   generatedPath: String!
+  """Path to the config file used"""
+  configFilePath: String!
+  """Path to scrapers"""
+  scrapersPath: String!
   """Path to cache"""
   cachePath: String!
   """Whether to calculate MD5 checksums for scene video files"""
   calculateMD5: Boolean!
   """Hash algorithm to use for generated file naming"""
   videoFileNamingAlgorithm: HashAlgorithm!
+  """Number of parallel tasks to start during scan/generate"""
+  parallelTasks: Int!
+  """Include audio stream in previews"""
+  previewAudio: Boolean!
   """Number of segments in a preview file"""
   previewSegments: Int!
   """Preview segment duration, in seconds"""
@@ -110,6 +136,8 @@ type ConfigGeneralResult {
   maxTranscodeSize: StreamingResolutionEnum
   """Max streaming transcode size"""
   maxStreamingTranscodeSize: StreamingResolutionEnum
+  """API Key"""
+  apiKey: String!
   """Username"""
   username: String!
   """Password"""
@@ -136,15 +164,21 @@ type ConfigGeneralResult {
   excludes: [String!]!
   """Array of file regexp to exclude from Image Scans"""
   imageExcludes: [String!]!
+  """Custom Performer Image Location"""
+  customPerformerImageLocation: String
   """Scraper user agent string"""
-  scraperUserAgent: String
+  scraperUserAgent: String @deprecated(reason: "use ConfigResult.scraping instead")
   """Scraper CDP path. Path to chrome executable or remote address"""
-  scraperCDPPath: String
+  scraperCDPPath: String @deprecated(reason: "use ConfigResult.scraping instead")
+  """Whether the scraper should check for invalid certificates"""
+  scraperCertCheck: Boolean! @deprecated(reason: "use ConfigResult.scraping instead")
   """Stash-box instances used for tagging"""
   stashBoxes: [StashBox!]!
 }
 
 input ConfigInterfaceInput {
+  """Ordered list of items that should be shown in the menu"""
+  menuItems: [String!]
   """Enable sound on mouseover previews"""
   soundOnPreview: Boolean
   """Show title and tags in wall view"""
@@ -160,10 +194,19 @@ input ConfigInterfaceInput {
   """Custom CSS"""
   css: String
   cssEnabled: Boolean
+  """Interface language"""
   language: String
+  """Slideshow Delay"""
+  slideshowDelay: Int
+  """Handy Connection Key"""
+  handyKey: String
+  """Funscript Time Offset"""
+  funscriptOffset: Int
 }
 
 type ConfigInterfaceResult {
+  """Ordered list of items that should be shown in the menu"""
+  menuItems: [String!]
   """Enable sound on mouseover previews"""
   soundOnPreview: Boolean
   """Show title and tags in wall view"""
@@ -174,19 +217,69 @@ type ConfigInterfaceResult {
   maximumLoopDuration: Int
   """If true, video will autostart on load in the scene player"""
   autostartVideo: Boolean
-   """If true, studio overlays will be shown as text instead of logo images"""
+  """If true, studio overlays will be shown as text instead of logo images"""
   showStudioAsText: Boolean
   """Custom CSS"""
   css: String
   cssEnabled: Boolean
   """Interface language"""
   language: String
+  """Slideshow Delay"""
+  slideshowDelay: Int
+  """Handy Connection Key"""
+  handyKey: String
+  """Funscript Time Offset"""
+  funscriptOffset: Int
+}
+
+input ConfigDLNAInput {
+  serverName: String
+  """True if DLNA service should be enabled by default"""
+  enabled: Boolean
+  """List of IPs whitelisted for DLNA service"""
+  whitelistedIPs: [String!]
+  """List of interfaces to run DLNA on. Empty for all"""
+  interfaces: [String!]
+}
+
+type ConfigDLNAResult {
+  serverName: String!
+  """True if DLNA service should be enabled by default"""
+  enabled: Boolean!
+  """List of IPs whitelisted for DLNA service"""
+  whitelistedIPs: [String!]!
+  """List of interfaces to run DLNA on. Empty for all"""
+  interfaces: [String!]!
+}
+
+input ConfigScrapingInput {
+  """Scraper user agent string"""
+  scraperUserAgent: String
+  """Scraper CDP path. Path to chrome executable or remote address"""
+  scraperCDPPath: String
+  """Whether the scraper should check for invalid certificates"""
+  scraperCertCheck: Boolean!
+  """Tags blacklist during scraping"""
+  excludeTagPatterns: [String!]
+}
+
+type ConfigScrapingResult {
+  """Scraper user agent string"""
+  scraperUserAgent: String
+  """Scraper CDP path. Path to chrome executable or remote address"""
+  scraperCDPPath: String
+  """Whether the scraper should check for invalid certificates"""
+  scraperCertCheck: Boolean!
+  """Tags blacklist during scraping"""
+  excludeTagPatterns: [String!]!
 }
 
 """All configuration settings"""
 type ConfigResult {
   general: ConfigGeneralResult!
   interface: ConfigInterfaceResult!
+  dlna: ConfigDLNAResult!
+  scraping: ConfigScrapingResult!
 }
 
 """Directory structure of a path"""
@@ -208,3 +301,7 @@ type StashConfig {
   excludeVideo: Boolean!
   excludeImage: Boolean!
 }
+
+input GenerateAPIKeyInput {
+  clear: Boolean
+}

graphql/schema/types/dlna.graphql

@@ -0,0 +1,35 @@
+
+
+type DLNAIP {
+    ipAddress: String!
+    """Time until IP will be no longer allowed/disallowed"""
+    until: Time
+}
+
+type DLNAStatus {
+    running: Boolean!
+    """If not currently running, time until it will be started. If running, time until it will be stopped"""
+    until: Time
+    recentIPAddresses: [String!]!
+    allowedIPAddresses: [DLNAIP!]!
+}
+
+input EnableDLNAInput {
+    """Duration to enable, in minutes. 0 or null for indefinite."""
+    duration: Int
+}
+ 
+input DisableDLNAInput {
+    """Duration to enable, in minutes. 0 or null for indefinite."""
+    duration: Int
+}
+
+input AddTempDLNAIPInput {
+    address: String!
+    """Duration to enable, in minutes. 0 or null for indefinite."""
+    duration: Int
+}
+
+input RemoveTempDLNAIPInput {
+    address: String!
+}

graphql/schema/types/filters.graphql

@@ -6,20 +6,41 @@ enum SortDirectionEnum {
 input FindFilterType {
   q: String
   page: Int
+  """use per_page = -1 to indicate all results. Defaults to 25."""
   per_page: Int
   sort: String
   direction: SortDirectionEnum
 }
 
 enum ResolutionEnum {
+  "144p", VERY_LOW
   "240p", LOW
+  "360p", R360P
   "480p", STANDARD
+  "540p", WEB_HD
   "720p", STANDARD_HD
   "1080p", FULL_HD
+  "1440p", QUAD_HD
+  "1920p", VR_HD
   "4k", FOUR_K
+  "5k", FIVE_K
+  "6k", SIX_K
+  "8k", EIGHT_K
+}
+
+input ResolutionCriterionInput {
+  value: ResolutionEnum!
+  modifier: CriterionModifier!
 }
 
 input PerformerFilterType {
+  AND: PerformerFilterType
+  OR: PerformerFilterType
+  NOT: PerformerFilterType
+
+  name: StringCriterionInput
+  details: StringCriterionInput
+
   """Filter by favorite"""
   filter_favorites: Boolean
   """Filter by birth year"""
@@ -38,7 +59,7 @@ input PerformerFilterType {
   measurements: StringCriterionInput
   """Filter by fake tits value"""
   fake_tits: StringCriterionInput
-  """Filter by career length"""  
+  """Filter by career length"""
   career_length: StringCriterionInput
   """Filter by tattoos"""
   tattoos: StringCriterionInput
@@ -50,8 +71,30 @@ input PerformerFilterType {
   gender: GenderCriterionInput
   """Filter to only include performers missing this property"""
   is_missing: String
+  """Filter to only include performers with these tags"""
+  tags: MultiCriterionInput
+  """Filter by tag count"""
+  tag_count: IntCriterionInput
+  """Filter by scene count"""
+  scene_count: IntCriterionInput
+  """Filter by image count"""
+  image_count: IntCriterionInput
+  """Filter by gallery count"""
+  gallery_count: IntCriterionInput
   """Filter by StashID"""
-  stash_id: String
+  stash_id: StringCriterionInput
+  """Filter by rating"""
+  rating: IntCriterionInput
+  """Filter by url"""
+  url: StringCriterionInput
+  """Filter by hair color"""
+  hair_color: StringCriterionInput
+  """Filter by weight"""
+  weight: IntCriterionInput
+  """Filter by death year"""
+  death_year: IntCriterionInput
+  """Filter by studios where performer appears in scene/image/gallery"""
+  studios: HierarchicalMultiCriterionInput
 }
 
 input SceneMarkerFilterType {
@@ -66,14 +109,29 @@ input SceneMarkerFilterType {
 }
 
 input SceneFilterType {
+  AND: SceneFilterType
+  OR: SceneFilterType
+  NOT: SceneFilterType
+
+  title: StringCriterionInput
+  details: StringCriterionInput
+
+  """Filter by file oshash"""
+  oshash: StringCriterionInput
+  """Filter by file checksum"""
+  checksum: StringCriterionInput
+  """Filter by file phash"""
+  phash: StringCriterionInput
   """Filter by path"""
   path: StringCriterionInput
   """Filter by rating"""
   rating: IntCriterionInput
+  """Filter by organized"""
+  organized: Boolean
   """Filter by o-counter"""
   o_counter: IntCriterionInput
   """Filter by resolution"""
-  resolution: ResolutionEnum
+  resolution: ResolutionCriterionInput
   """Filter by duration (in seconds)"""
   duration: IntCriterionInput
   """Filter to only include scenes which have markers. `true` or `false`"""
@@ -81,34 +139,76 @@ input SceneFilterType {
   """Filter to only include scenes missing this property"""
   is_missing: String
   """Filter to only include scenes with this studio"""
-  studios: MultiCriterionInput
+  studios: HierarchicalMultiCriterionInput
   """Filter to only include scenes with this movie"""
   movies: MultiCriterionInput
   """Filter to only include scenes with these tags"""
   tags: MultiCriterionInput
+  """Filter by tag count"""
+  tag_count: IntCriterionInput
+  """Filter to only include scenes with performers with these tags"""
+  performer_tags: MultiCriterionInput
   """Filter to only include scenes with these performers"""
   performers: MultiCriterionInput
+  """Filter by performer count"""
+  performer_count: IntCriterionInput
   """Filter by StashID"""
-  stash_id: String
+  stash_id: StringCriterionInput
+  """Filter by url"""
+  url: StringCriterionInput
+  """Filter by interactive"""
+  interactive: Boolean
 }
 
 input MovieFilterType {
+
+  name: StringCriterionInput
+  director: StringCriterionInput
+  synopsis: StringCriterionInput
+
+  """Filter by duration (in seconds)"""
+  duration: IntCriterionInput
+  """Filter by rating"""
+  rating: IntCriterionInput
   """Filter to only include movies with this studio"""
-  studios: MultiCriterionInput
+  studios: HierarchicalMultiCriterionInput
   """Filter to only include movies missing this property"""
   is_missing: String
+  """Filter by url"""
+  url: StringCriterionInput
 }
 
 input StudioFilterType {
+  name: StringCriterionInput
+  details: StringCriterionInput
   """Filter to only include studios with this parent studio"""
   parents: MultiCriterionInput
   """Filter by StashID"""
-  stash_id: String
+  stash_id: StringCriterionInput
   """Filter to only include studios missing this property"""
   is_missing: String
+  """Filter by rating"""
+  rating: IntCriterionInput
+  """Filter by scene count"""
+  scene_count: IntCriterionInput
+  """Filter by image count"""
+  image_count: IntCriterionInput
+  """Filter by gallery count"""
+  gallery_count: IntCriterionInput
+  """Filter by url"""
+  url: StringCriterionInput
 }
 
 input GalleryFilterType {
+  AND: GalleryFilterType
+  OR: GalleryFilterType
+  NOT: GalleryFilterType
+
+  title: StringCriterionInput
+  details: StringCriterionInput
+
+  """Filter by file checksum"""
+  checksum: StringCriterionInput
   """Filter by path"""
   path: StringCriterionInput
   """Filter to only include galleries missing this property"""
@@ -117,46 +217,91 @@ input GalleryFilterType {
   is_zip: Boolean
   """Filter by rating"""
   rating: IntCriterionInput
+  """Filter by organized"""
+  organized: Boolean
   """Filter by average image resolution"""
-  average_resolution: ResolutionEnum
-  """Filter to only include scenes with this studio"""
-  studios: MultiCriterionInput
-  """Filter to only include scenes with these tags"""
+  average_resolution: ResolutionCriterionInput
+  """Filter to only include galleries with this studio"""
+  studios: HierarchicalMultiCriterionInput
+  """Filter to only include galleries with these tags"""
   tags: MultiCriterionInput
-  """Filter to only include scenes with these performers"""
+  """Filter by tag count"""
+  tag_count: IntCriterionInput
+  """Filter to only include galleries with performers with these tags"""
+  performer_tags: MultiCriterionInput
+  """Filter to only include galleries with these performers"""
   performers: MultiCriterionInput
+  """Filter by performer count"""
+  performer_count: IntCriterionInput
   """Filter by number of images in this gallery"""
   image_count: IntCriterionInput
+  """Filter by url"""
+  url: StringCriterionInput
 }
 
 input TagFilterType {
+  AND: TagFilterType
+  OR: TagFilterType
+  NOT: TagFilterType
+
+  """Filter by tag name"""
+  name: StringCriterionInput
+
+  """Filter by tag aliases"""
+  aliases: StringCriterionInput
+
   """Filter to only include tags missing this property"""
   is_missing: String
 
   """Filter by number of scenes with this tag"""
   scene_count: IntCriterionInput
 
+  """Filter by number of images with this tag"""
+  image_count: IntCriterionInput
+
+  """Filter by number of galleries with this tag"""
+  gallery_count: IntCriterionInput
+
+  """Filter by number of performers with this tag"""
+  performer_count: IntCriterionInput
+
   """Filter by number of markers with this tag"""
   marker_count: IntCriterionInput
 }
 
 input ImageFilterType {
+  AND: ImageFilterType
+  OR: ImageFilterType
+  NOT: ImageFilterType
+
+  title: StringCriterionInput
+
+  """Filter by file checksum"""
+  checksum: StringCriterionInput
   """Filter by path"""
   path: StringCriterionInput
   """Filter by rating"""
   rating: IntCriterionInput
+  """Filter by organized"""
+  organized: Boolean
   """Filter by o-counter"""
   o_counter: IntCriterionInput
   """Filter by resolution"""
-  resolution: ResolutionEnum
+  resolution: ResolutionCriterionInput
   """Filter to only include images missing this property"""
   is_missing: String
   """Filter to only include images with this studio"""
-  studios: MultiCriterionInput
+  studios: HierarchicalMultiCriterionInput
   """Filter to only include images with these tags"""
   tags: MultiCriterionInput
+  """Filter by tag count"""
+  tag_count: IntCriterionInput
+  """Filter to only include images with performers with these tags"""
+  performer_tags: MultiCriterionInput
   """Filter to only include images with these performers"""
   performers: MultiCriterionInput
+  """Filter by performer count"""
+  performer_count: IntCriterionInput
   """Filter to only include images with these galleries"""
   galleries: MultiCriterionInput
 }
@@ -178,6 +323,14 @@ enum CriterionModifier {
   INCLUDES_ALL,
   INCLUDES,
   EXCLUDES,
+  """MATCHES REGEX"""
+  MATCHES_REGEX,
+  """NOT MATCHES REGEX"""
+  NOT_MATCHES_REGEX,
+  """>= AND <="""
+  BETWEEN,
+  """< OR >"""
+  NOT_BETWEEN,
 }
 
 input StringCriterionInput {
@@ -187,6 +340,7 @@ input StringCriterionInput {
 
 input IntCriterionInput {
   value: Int!
+  value2: Int
   modifier: CriterionModifier!
 }
 
@@ -199,3 +353,47 @@ input GenderCriterionInput {
   value: GenderEnum
   modifier: CriterionModifier!
 }
+
+input HierarchicalMultiCriterionInput {
+  value: [ID!]
+  modifier: CriterionModifier!
+  depth: Int!
+}
+
+enum FilterMode {
+  SCENES,
+  PERFORMERS,
+  STUDIOS,
+  GALLERIES,
+  SCENE_MARKERS,
+  MOVIES,
+  TAGS,
+  IMAGES,
+}
+
+type SavedFilter {
+  id: ID!
+  mode: FilterMode!
+  name: String!
+  """JSON-encoded filter string"""
+  filter: String!
+}
+
+input SaveFilterInput {
+  """provide ID to overwrite existing filter"""
+  id: ID
+  mode: FilterMode!
+  name: String!
+  """JSON-encoded filter string"""
+  filter: String!
+}
+
+input DestroyFilterInput {
+  id: ID!
+}
+
+input SetDefaultFilterInput {
+  mode: FilterMode!
+  """JSON-encoded filter string - null to clear"""
+  filter: String
+}

graphql/schema/types/gallery.graphql

@@ -8,7 +8,12 @@ type Gallery {
   date: String
   details: String
   rating: Int
-  scene: Scene
+  organized: Boolean!
+  created_at: Time!
+  updated_at: Time!
+  file_mod_time: Time
+
+  scenes: [Scene!]!
   studio: Studio
   image_count: Int!
   tags: [Tag!]!
@@ -31,7 +36,8 @@ input GalleryCreateInput {
   date: String
   details: String
   rating: Int
-  scene_id: ID
+  organized: Boolean
+  scene_ids: [ID!]
   studio_id: ID
   tag_ids: [ID!]
   performer_ids: [ID!]
@@ -45,7 +51,8 @@ input GalleryUpdateInput {
   date: String
   details: String
   rating: Int
-  scene_id: ID
+  organized: Boolean
+  scene_ids: [ID!]
   studio_id: ID
   tag_ids: [ID!]
   performer_ids: [ID!]
@@ -58,7 +65,8 @@ input BulkGalleryUpdateInput {
   date: String
   details: String
   rating: Int
-  scene_id: ID
+  organized: Boolean
+  scene_ids: BulkUpdateIds
   studio_id: ID
   tag_ids: BulkUpdateIds
   performer_ids: BulkUpdateIds

graphql/schema/types/image.graphql

@@ -4,7 +4,11 @@ type Image {
   title: String
   rating: Int
   o_counter: Int
+  organized: Boolean!
   path: String!
+  created_at: Time!
+  updated_at: Time!
+  file_mod_time: Time
 
   file: ImageFileType! # Resolver
   paths: ImagePathsType! # Resolver
@@ -31,6 +35,7 @@ input ImageUpdateInput {
   id: ID!
   title: String
   rating: Int
+  organized: Boolean
   
   studio_id: ID
   performer_ids: [ID!]
@@ -43,6 +48,7 @@ input BulkImageUpdateInput {
   ids: [ID!]
   title: String
   rating: Int
+  organized: Boolean
   
   studio_id: ID
   performer_ids: BulkUpdateIds

graphql/schema/types/job.graphql

@@ -0,0 +1,33 @@
+enum JobStatus {
+  READY
+  RUNNING
+  FINISHED
+  STOPPING
+  CANCELLED
+}
+
+type Job {
+  id: ID!
+  status: JobStatus!
+  subTasks: [String!]
+  description: String!
+  progress: Float
+  startTime: Time
+  endTime: Time
+  addTime: Time!
+}
+
+input FindJobInput {
+  id: ID!
+}
+
+enum JobStatusUpdateType {
+  ADD
+  REMOVE
+  UPDATE
+}
+
+type JobStatusUpdate {
+  type: JobStatusUpdateType!
+  job: Job!
+}

graphql/schema/types/metadata.graphql

@@ -7,6 +7,7 @@ input GenerateMetadataInput {
   previewOptions: GeneratePreviewOptionsInput
   markers: Boolean!
   transcodes: Boolean!
+  phashes: Boolean!
 
   """scene ids to generate for"""
   sceneIDs: [ID!]
@@ -32,10 +33,28 @@ input GeneratePreviewOptionsInput {
 
 input ScanMetadataInput {
   paths: [String!]
-  useFileMetadata: Boolean!
+  """Set name, date, details from metadata (if present)"""
+  useFileMetadata: Boolean
+  """Strip file extension from title"""
+  stripFileExtension: Boolean
+  """Generate previews during scan"""
+  scanGeneratePreviews: Boolean
+  """Generate image previews during scan"""
+  scanGenerateImagePreviews: Boolean
+  """Generate sprites during scan"""
+  scanGenerateSprites: Boolean
+  """Generate phashes during scan"""
+  scanGeneratePhashes: Boolean
+}
+
+input CleanMetadataInput {
+  """Do a dry run. Don't delete any files"""
+  dryRun: Boolean!
 }
 
 input AutoTagMetadataInput {
+  """Paths to tag, null for all files"""
+  paths: [String!]
   """IDs of performers to tag files with, or "*" for all"""
   performers: [String!]
   """IDs of studios to tag files with, or "*" for all"""
@@ -44,12 +63,6 @@ input AutoTagMetadataInput {
   tags: [String!]
 }
 
-type MetadataUpdateStatus {
-  progress: Float!
-  status: String!
-  message: String!
-}
-
 input ExportObjectTypeInput {
   ids: [String!]
   all: Boolean
@@ -83,3 +96,25 @@ input ImportObjectsInput {
   duplicateBehaviour: ImportDuplicateEnum!
   missingRefBehaviour: ImportMissingRefEnum!
 }
+
+input BackupDatabaseInput {
+  download: Boolean
+}
+
+enum SystemStatusEnum {
+  SETUP
+  NEEDS_MIGRATION
+  OK
+}
+
+type SystemStatus {
+  databaseSchema: Int
+  databasePath: String
+  configPath: String
+  appSchema: Int!
+  status: SystemStatusEnum!
+}
+
+input MigrateInput {
+  backupPath: String!
+}

graphql/schema/types/movie.graphql

@@ -11,6 +11,8 @@ type Movie {
   director: String
   synopsis: String
   url: String
+  created_at: Time!
+  updated_at: Time!
 
   front_image_path: String # Resolver
   back_image_path: String # Resolver
@@ -28,8 +30,9 @@ input MovieCreateInput {
   director: String
   synopsis: String
   url: String
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   front_image: String
+  """This should be a URL or a base64 encoded data URL"""
   back_image: String
 }
 
@@ -44,8 +47,9 @@ input MovieUpdateInput {
   director: String
   synopsis: String
   url: String
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   front_image: String
+  """This should be a URL or a base64 encoded data URL"""
   back_image: String
 }
 

graphql/schema/types/performer.graphql

@@ -27,11 +27,21 @@ type Performer {
   piercings: String
   aliases: String
   favorite: Boolean!
+  tags: [Tag!]!
 
   image_path: String # Resolver
   scene_count: Int # Resolver
+  image_count: Int # Resolver
+  gallery_count: Int # Resolver
   scenes: [Scene!]!
   stash_ids: [StashID!]!
+  rating: Int
+  details: String
+  death_date: String
+  hair_color: String
+  weight: Int
+  created_at: Time!
+  updated_at: Time!
 }
 
 input PerformerCreateInput {
@@ -52,9 +62,15 @@ input PerformerCreateInput {
   twitter: String
   instagram: String
   favorite: Boolean
-  """This should be base64 encoded"""
+  tag_ids: [ID!]
+  """This should be a URL or a base64 encoded data URL"""
   image: String
   stash_ids: [StashIDInput!]
+  rating: Int
+  details: String
+  death_date: String
+  hair_color: String
+  weight: Int
 }
 
 input PerformerUpdateInput {
@@ -76,9 +92,42 @@ input PerformerUpdateInput {
   twitter: String
   instagram: String
   favorite: Boolean
-  """This should be base64 encoded"""
+  tag_ids: [ID!]
+  """This should be a URL or a base64 encoded data URL"""
   image: String
   stash_ids: [StashIDInput!]
+  rating: Int
+  details: String
+  death_date: String
+  hair_color: String
+  weight: Int
+}
+
+input BulkPerformerUpdateInput {
+  clientMutationId: String
+  ids: [ID!]
+  url: String
+  gender: GenderEnum
+  birthdate: String
+  ethnicity: String
+  country: String
+  eye_color: String
+  height: String
+  measurements: String
+  fake_tits: String
+  career_length: String
+  tattoos: String
+  piercings: String
+  aliases: String
+  twitter: String
+  instagram: String
+  favorite: Boolean
+  tag_ids: BulkUpdateIds
+  rating: Int
+  details: String
+  death_date: String
+  hair_color: String
+  weight: Int
 }
 
 input PerformerDestroyInput {

graphql/schema/types/plugin.graphql

@@ -7,6 +7,7 @@ type Plugin {
     version: String
 
     tasks: [PluginTask!]
+    hooks: [PluginHook!]
 }
 
 type PluginTask {
@@ -15,6 +16,13 @@ type PluginTask {
     plugin: Plugin!
 }
 
+type PluginHook {
+    name: String!
+    description: String
+    hooks: [String!]
+    plugin: Plugin!
+}
+
 type PluginResult {
     error: String
     result: String

graphql/schema/types/scene-marker.graphql

@@ -5,6 +5,8 @@ type SceneMarker {
   seconds: Float!
   primary_tag: Tag!
   tags: [Tag!]!
+  created_at: Time!
+  updated_at: Time!
 
   """The path to stream this marker"""
   stream: String! # Resolver

graphql/schema/types/scene.graphql

@@ -16,6 +16,8 @@ type ScenePathsType {
   webp: String # Resolver
   vtt: String # Resolver
   chapters_vtt: String # Resolver
+  sprite: String # Resolver
+  funscript: String # Resolver
 }
 
 type SceneMovie {
@@ -32,14 +34,20 @@ type Scene {
   url: String
   date: String
   rating: Int
+  organized: Boolean!
   o_counter: Int
   path: String!
+  phash: String
+  interactive: Boolean!
+  created_at: Time!
+  updated_at: Time!
+  file_mod_time: Time
 
   file: SceneFileType! # Resolver
   paths: ScenePathsType! # Resolver
 
   scene_markers: [SceneMarker!]!
-  gallery: Gallery
+  galleries: [Gallery!]!
   studio: Studio
   movies: [SceneMovie!]!
   tags: [Tag!]!
@@ -60,12 +68,13 @@ input SceneUpdateInput {
   url: String
   date: String
   rating: Int
+  organized: Boolean
   studio_id: ID
-  gallery_id: ID
+  gallery_ids: [ID!]
   performer_ids: [ID!]
   movies: [SceneMovieInput!]
   tag_ids: [ID!]
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   cover_image: String
   stash_ids: [StashIDInput!]
 }
@@ -89,8 +98,9 @@ input BulkSceneUpdateInput {
   url: String
   date: String
   rating: Int
+  organized: Boolean
   studio_id: ID
-  gallery_id: ID
+  gallery_ids: BulkUpdateIds
   performer_ids: BulkUpdateIds
   tag_ids: BulkUpdateIds
 }
@@ -115,7 +125,8 @@ type FindScenesResultType {
 input SceneParserInput {
   ignoreWords: [String!],
   whitespaceCharacters: String,
-  capitalizeTitle: Boolean
+  capitalizeTitle: Boolean,
+  ignoreOrganized: Boolean
 }
 
 type SceneMovieID {
@@ -131,7 +142,7 @@ type SceneParserResult {
   date: String
   rating: Int
   studio_id: ID
-  gallery_id: ID
+  gallery_ids: [ID!]
   performer_ids: [ID!]
   movies: [SceneMovieID!]
   tag_ids: [ID!]

graphql/schema/types/scraped-movie.graphql

@@ -17,8 +17,9 @@ type ScrapedMovie {
   synopsis: String
   studio: ScrapedMovieStudio
 
-  """This should be base64 encoded"""
+  """This should be a base64 encoded data URL"""
   front_image: String
+  """This should be a base64 encoded data URL"""
   back_image: String
 }
 

graphql/schema/types/scraped-performer.graphql

@@ -16,9 +16,16 @@ type ScrapedPerformer {
   tattoos: String
   piercings: String
   aliases: String
+  # Should be ScrapedPerformerTag - but would be identical types
+  tags: [ScrapedSceneTag!]
 
-  """This should be base64 encoded"""
+  """This should be a base64 encoded data URL"""
   image: String
+  details: String
+  death_date: String
+  hair_color: String
+  weight: String
+  remote_site_id: String
 }
 
 input ScrapedPerformerInput {
@@ -39,5 +46,11 @@ input ScrapedPerformerInput {
   piercings: String
   aliases: String
 
+  # not including tags for the input
   # not including image for the input
+  details: String
+  death_date: String
+  hair_color: String
+  weight: String
+  remote_site_id: String
 }

graphql/schema/types/scraper.graphql

@@ -45,9 +45,14 @@ type ScrapedScenePerformer {
   tattoos: String
   piercings: String
   aliases: String
+  tags: [ScrapedSceneTag!]
 
   remote_site_id: String
   images: [String!]
+  details: String
+  death_date: String
+  hair_color: String
+  weight: String
 }
 
 type ScrapedSceneMovie {
@@ -84,7 +89,7 @@ type ScrapedScene {
   url: String
   date: String
 
-  """This should be base64 encoded"""
+  """This should be a base64 encoded data URL"""
   image: String
 
   file: SceneFileType # Resolver
@@ -110,7 +115,7 @@ type ScrapedGallery {
   performers: [ScrapedScenePerformer!]
 }
 
-input StashBoxQueryInput {
+input StashBoxSceneQueryInput {
   """Index of the configured stash-box instance to use"""
   stash_box_index: Int!
   """Instructs query by scene fingerprints"""
@@ -119,8 +124,30 @@ input StashBoxQueryInput {
   q: String
 }
 
+input StashBoxPerformerQueryInput {
+  """Index of the configured stash-box instance to use"""
+  stash_box_index: Int!
+  """Instructs query by scene fingerprints"""
+  performer_ids: [ID!]
+  """Query by query string"""
+  q: String
+}
+
+type StashBoxPerformerQueryResult {
+  query: String!
+  results: [ScrapedScenePerformer!]!
+}
+
 type StashBoxFingerprint {
   algorithm: String!
   hash: String!
   duration: Int!
 }
+
+input StashBoxBatchPerformerTagInput {
+  endpoint: Int!
+  exclude_fields: [String!]
+  refresh: Boolean!
+  performer_ids: [ID!]
+  performer_names: [String!]
+}

graphql/schema/types/stats.graphql

@@ -1,8 +1,9 @@
 type StatsResultType {
   scene_count: Int!
-  scenes_size: Int!
+  scenes_size: Float!
+  scenes_duration: Float!
   image_count: Int!
-  images_size: Int!
+  images_size: Float!
   gallery_count: Int!
   performer_count: Int!
   studio_count: Int!

graphql/schema/types/studio.graphql

@@ -8,16 +8,24 @@ type Studio {
 
   image_path: String # Resolver
   scene_count: Int # Resolver
+  image_count: Int # Resolver
+  gallery_count: Int # Resolver
   stash_ids: [StashID!]!
+  rating: Int
+  details: String
+  created_at: Time!
+  updated_at: Time!
 }
 
 input StudioCreateInput {
   name: String!
   url: String
   parent_id: ID
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   image: String
   stash_ids: [StashIDInput!]
+  rating: Int
+  details: String
 }
 
 input StudioUpdateInput {
@@ -25,9 +33,11 @@ input StudioUpdateInput {
   name: String
   url: String
   parent_id: ID,
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   image: String
   stash_ids: [StashIDInput!]
+  rating: Int
+  details: String
 }
 
 input StudioDestroyInput {

graphql/schema/types/tag.graphql

@@ -1,24 +1,32 @@
 type Tag {
   id: ID!
   name: String!
+  aliases: [String!]!
+  created_at: Time!
+  updated_at: Time!
 
   image_path: String # Resolver
   scene_count: Int # Resolver
   scene_marker_count: Int # Resolver
+  image_count: Int # Resolver
+  gallery_count: Int # Resolver
+  performer_count: Int
 }
 
 input TagCreateInput {
   name: String!
+  aliases: [String!]
 
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   image: String
 }
 
 input TagUpdateInput {
   id: ID!
-  name: String!
+  name: String
+  aliases: [String!]
 
-  """This should be base64 encoded"""
+  """This should be a URL or a base64 encoded data URL"""
   image: String
 }
 
@@ -29,4 +37,9 @@ input TagDestroyInput {
 type FindTagsResultType {
   count: Int!
   tags: [Tag!]!
-}
+}
+
+input TagsMergeInput {
+  source: [ID!]!
+  destination: ID!
+}

graphql/stash-box/query.graphql

@@ -75,6 +75,11 @@ fragment PerformerFragment on Performer {
   piercings {
     ...BodyModificationFragment
   }
+  details
+  death_date {
+    ...FuzzyDateFragment
+  }
+  weight
 }
 
 fragment PerformerAppearanceFragment on PerformerAppearance {
@@ -134,6 +139,18 @@ query SearchScene($term: String!) {
   }
 }
 
+query SearchPerformer($term: String!) {
+  searchPerformer(term: $term) {
+    ...PerformerFragment
+  }
+}
+
+query FindPerformerByID($id: ID!) {
+  findPerformer(id: $id) {
+    ...PerformerFragment
+  }
+}
+
 mutation SubmitFingerprint($input: FingerprintSubmission!) {
   submitFingerprint(input: $input)
 }

main.go

@@ -2,10 +2,13 @@
 package main
 
 import (
+	"os"
+	"os/signal"
+	"runtime/pprof"
+	"syscall"
+
 	"github.com/stashapp/stash/pkg/api"
-	"github.com/stashapp/stash/pkg/database"
 	"github.com/stashapp/stash/pkg/manager"
-	"github.com/stashapp/stash/pkg/manager/config"
 
 	_ "github.com/golang-migrate/migrate/v4/database/sqlite3"
 	_ "github.com/golang-migrate/migrate/v4/source/file"
@@ -13,16 +16,17 @@ import (
 
 func main() {
 	manager.Initialize()
-
-	// perform the post-migration for new databases
-	if database.Initialize(config.GetDatabasePath()) {
-		manager.GetInstance().PostMigrate()
-	}
-
 	api.Start()
+
+	// stop any profiling at exit
+	defer pprof.StopCPUProfile()
 	blockForever()
 }
 
 func blockForever() {
-	select {}
+	// handle signals
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+
+	<-signals
 }

pkg/api/changeset_translator.go

@@ -0,0 +1,150 @@
+package api
+
+import (
+	"context"
+	"database/sql"
+	"strconv"
+
+	"github.com/99designs/gqlgen/graphql"
+	"github.com/stashapp/stash/pkg/models"
+)
+
+const updateInputField = "input"
+
+func getArgumentMap(ctx context.Context) map[string]interface{} {
+	rctx := graphql.GetFieldContext(ctx)
+	reqCtx := graphql.GetOperationContext(ctx)
+	return rctx.Field.ArgumentMap(reqCtx.Variables)
+}
+
+func getUpdateInputMap(ctx context.Context) map[string]interface{} {
+	args := getArgumentMap(ctx)
+
+	input, _ := args[updateInputField]
+	var ret map[string]interface{}
+	if input != nil {
+		ret, _ = input.(map[string]interface{})
+	}
+
+	if ret == nil {
+		ret = make(map[string]interface{})
+	}
+
+	return ret
+}
+
+func getUpdateInputMaps(ctx context.Context) []map[string]interface{} {
+	args := getArgumentMap(ctx)
+
+	input, _ := args[updateInputField]
+	var ret []map[string]interface{}
+	if input != nil {
+		// convert []interface{} into []map[string]interface{}
+		iSlice, _ := input.([]interface{})
+		for _, i := range iSlice {
+			m, _ := i.(map[string]interface{})
+			if m != nil {
+				ret = append(ret, m)
+			}
+		}
+	}
+
+	return ret
+}
+
+type changesetTranslator struct {
+	inputMap map[string]interface{}
+}
+
+func (t changesetTranslator) hasField(field string) bool {
+	if t.inputMap == nil {
+		return false
+	}
+
+	_, found := t.inputMap[field]
+	return found
+}
+
+func (t changesetTranslator) getFields() []string {
+	var ret []string
+	for k := range t.inputMap {
+		ret = append(ret, k)
+	}
+
+	return ret
+}
+
+func (t changesetTranslator) nullString(value *string, field string) *sql.NullString {
+	if !t.hasField(field) {
+		return nil
+	}
+
+	ret := &sql.NullString{}
+
+	if value != nil {
+		ret.String = *value
+		ret.Valid = true
+	}
+
+	return ret
+}
+
+func (t changesetTranslator) sqliteDate(value *string, field string) *models.SQLiteDate {
+	if !t.hasField(field) {
+		return nil
+	}
+
+	ret := &models.SQLiteDate{}
+
+	if value != nil {
+		ret.String = *value
+		ret.Valid = true
+	}
+
+	return ret
+}
+
+func (t changesetTranslator) nullInt64(value *int, field string) *sql.NullInt64 {
+	if !t.hasField(field) {
+		return nil
+	}
+
+	ret := &sql.NullInt64{}
+
+	if value != nil {
+		ret.Int64 = int64(*value)
+		ret.Valid = true
+	}
+
+	return ret
+}
+
+func (t changesetTranslator) nullInt64FromString(value *string, field string) *sql.NullInt64 {
+	if !t.hasField(field) {
+		return nil
+	}
+
+	ret := &sql.NullInt64{}
+
+	if value != nil {
+		ret.Int64, _ = strconv.ParseInt(*value, 10, 64)
+		ret.Valid = true
+	}
+
+	return ret
+}
+
+func (t changesetTranslator) nullBool(value *bool, field string) *sql.NullBool {
+	if !t.hasField(field) {
+		return nil
+	}
+
+	ret := &sql.NullBool{}
+
+	if value != nil {
+		ret.Bool = *value
+		ret.Valid = true
+	}
+
+	return ret
+}

pkg/api/check_version.go

@@ -10,6 +10,8 @@ import (
 	"runtime"
 	"time"
 
+	"golang.org/x/sys/cpu"
+
 	"github.com/stashapp/stash/pkg/logger"
 )
 
@@ -18,6 +20,7 @@ const apiReleases string = "https://api.github.com/repos/stashapp/stash/releases
 const apiTags string = "https://api.github.com/repos/stashapp/stash/tags"
 const apiAcceptHeader string = "application/vnd.github.v3+json"
 const developmentTag string = "latest_develop"
+const defaultSHLength int = 7 // default length of SHA short hash returned by <git rev-parse --short HEAD>
 
 // ErrNoVersion indicates that no version information has been embedded in the
 // stash binary
@@ -25,10 +28,12 @@ var ErrNoVersion = errors.New("no stash version")
 
 var stashReleases = func() map[string]string {
 	return map[string]string{
-		"windows/amd64": "stash-win.exe",
-		"linux/amd64":   "stash-linux",
 		"darwin/amd64":  "stash-osx",
+		"linux/amd64":   "stash-linux",
+		"windows/amd64": "stash-win.exe",
 		"linux/arm":     "stash-pi",
+		"linux/arm64":   "stash-linux-arm64v8",
+		"linux/armv7":   "stash-linux-arm32v7",
 	}
 }
 
@@ -140,7 +145,13 @@ func makeGithubRequest(url string, output interface{}) error {
 // which is the latest pre-release build.
 func GetLatestVersion(shortHash bool) (latestVersion string, latestRelease string, err error) {
 
-	platform := fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)
+	arch := runtime.GOARCH                                                                    // https://en.wikipedia.org/wiki/Comparison_of_ARM_cores
+	isARMv7 := cpu.ARM.HasNEON || cpu.ARM.HasVFPv3 || cpu.ARM.HasVFPv3D16 || cpu.ARM.HasVFPv4 // armv6 doesn't support any of these features
+	if arch == "arm" && isARMv7 {
+		arch = "armv7"
+	}
+
+	platform := fmt.Sprintf("%s/%s", runtime.GOOS, arch)
 	wantedRelease := stashReleases()[platform]
 
 	version, _, _ := GetVersion()
@@ -191,14 +202,20 @@ func GetLatestVersion(shortHash bool) (latestVersion string, latestRelease strin
 }
 
 func getReleaseHash(release githubReleasesResponse, shortHash bool, usePreRelease bool) string {
+	shaLength := len(release.Target_commitish)
 	// the /latest API call doesn't return the hash in target_commitish
 	// also add sanity check in case Target_commitish is not 40 characters
-	if !usePreRelease || len(release.Target_commitish) != 40 {
+	if !usePreRelease || shaLength != 40 {
 		return getShaFromTags(shortHash, release.Tag_name)
 	}
 
 	if shortHash {
-		return release.Target_commitish[0:7] //shorthash is first 7 digits of git commit hash
+		last := defaultSHLength                                // default length of git short hash
+		_, gitShort, _ := GetVersion()                         // retrieve it to check actual length
+		if len(gitShort) > last && len(gitShort) < shaLength { // sometimes short hash is longer
+			last = len(gitShort)
+		}
+		return release.Target_commitish[0:last]
 	}
 
 	return release.Target_commitish
@@ -229,14 +246,20 @@ func getShaFromTags(shortHash bool, name string) string {
 		logger.Errorf("Github Tags Api %v", err)
 		return ""
 	}
+	_, gitShort, _ := GetVersion() // retrieve short hash to check actual length
 
 	for _, tag := range tags {
 		if tag.Name == name {
-			if len(tag.Commit.Sha) != 40 {
+			shaLength := len(tag.Commit.Sha)
+			if shaLength != 40 {
 				return ""
 			}
 			if shortHash {
-				return tag.Commit.Sha[0:7] //shorthash is first 7 digits of git commit hash
+				last := defaultSHLength                                // default length of git short hash
+				if len(gitShort) > last && len(gitShort) < shaLength { // sometimes short hash is longer
+					last = len(gitShort)
+				}
+				return tag.Commit.Sha[0:last]
 			}
 
 			return tag.Commit.Sha

pkg/api/context_keys.go

@@ -5,13 +5,12 @@ package api
 type key int
 
 const (
-	galleryKey   key = 0
-	performerKey key = 1
-	sceneKey     key = 2
-	studioKey    key = 3
-	movieKey     key = 4
-	ContextUser  key = 5
-	tagKey       key = 6
-	downloadKey  key = 7
-	imageKey     key = 8
+	galleryKey key = iota
+	performerKey
+	sceneKey
+	studioKey
+	movieKey
+	tagKey
+	downloadKey
+	imageKey
 )

pkg/api/images.go

@@ -1,49 +1,67 @@
 package api
 
 import (
-	"math/rand"
 	"strings"
 
 	"github.com/gobuffalo/packr/v2"
+	"github.com/stashapp/stash/pkg/logger"
+	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/utils"
 )
 
-var performerBox *packr.Box
-var performerBoxMale *packr.Box
+type imageBox struct {
+	box   *packr.Box
+	files []string
+}
+
+func newImageBox(box *packr.Box) *imageBox {
+	return &imageBox{
+		box:   box,
+		files: box.List(),
+	}
+}
+
+var performerBox *imageBox
+var performerBoxMale *imageBox
+var performerBoxCustom *imageBox
 
 func initialiseImages() {
-	performerBox = packr.New("Performer Box", "../../static/performer")
-	performerBoxMale = packr.New("Male Performer Box", "../../static/performer_male")
+	performerBox = newImageBox(packr.New("Performer Box", "../../static/performer"))
+	performerBoxMale = newImageBox(packr.New("Male Performer Box", "../../static/performer_male"))
+	initialiseCustomImages()
 }
 
-func getRandomPerformerImage(gender string) ([]byte, error) {
-	var box *packr.Box
-	switch strings.ToUpper(gender) {
-	case "FEMALE":
-		box = performerBox
-	case "MALE":
-		box = performerBoxMale
-	default:
-		box = performerBox
-
+func initialiseCustomImages() {
+	customPath := config.GetInstance().GetCustomPerformerImageLocation()
+	if customPath != "" {
+		logger.Debugf("Loading custom performer images from %s", customPath)
+		// We need to set performerBoxCustom at runtime, as this is a custom path, and store it in a pointer.
+		performerBoxCustom = newImageBox(packr.Folder(customPath))
+	} else {
+		performerBoxCustom = nil
 	}
-	imageFiles := box.List()
-	index := rand.Intn(len(imageFiles))
-	return box.Find(imageFiles[index])
 }
 
-func getRandomPerformerImageUsingName(name, gender string) ([]byte, error) {
-	var box *packr.Box
-	switch strings.ToUpper(gender) {
-	case "FEMALE":
-		box = performerBox
-	case "MALE":
-		box = performerBoxMale
-	default:
-		box = performerBox
+func getRandomPerformerImageUsingName(name, gender, customPath string) ([]byte, error) {
+	var box *imageBox
 
+	// If we have a custom path, we should return a new box in the given path.
+	if performerBoxCustom != nil && len(performerBoxCustom.files) > 0 {
+		box = performerBoxCustom
 	}
-	imageFiles := box.List()
+
+	if box == nil {
+		switch strings.ToUpper(gender) {
+		case "FEMALE":
+			box = performerBox
+		case "MALE":
+			box = performerBoxMale
+		default:
+			box = performerBox
+		}
+	}
+
+	imageFiles := box.files
 	index := utils.IntFromString(name) % uint64(len(imageFiles))
-	return box.Find(imageFiles[index])
+	return box.box.Find(imageFiles[index])
 }

pkg/api/migrate.go

@@ -1,96 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"html/template"
-	"net/http"
-	"os"
-
-	"github.com/stashapp/stash/pkg/database"
-	"github.com/stashapp/stash/pkg/logger"
-	"github.com/stashapp/stash/pkg/manager"
-)
-
-type migrateData struct {
-	ExistingVersion uint
-	MigrateVersion  uint
-	BackupPath      string
-}
-
-func getMigrateData() migrateData {
-	return migrateData{
-		ExistingVersion: database.Version(),
-		MigrateVersion:  database.AppSchemaVersion(),
-		BackupPath:      database.DatabaseBackupPath(),
-	}
-}
-
-func getMigrateHandler(w http.ResponseWriter, r *http.Request) {
-	if !database.NeedsMigration() {
-		http.Redirect(w, r, "/", 301)
-		return
-	}
-
-	data, _ := setupUIBox.Find("migrate.html")
-	templ, err := template.New("Migrate").Parse(string(data))
-	if err != nil {
-		http.Error(w, fmt.Sprintf("error: %s", err), 500)
-		return
-	}
-
-	err = templ.Execute(w, getMigrateData())
-	if err != nil {
-		http.Error(w, fmt.Sprintf("error: %s", err), 500)
-	}
-}
-
-func doMigrateHandler(w http.ResponseWriter, r *http.Request) {
-	err := r.ParseForm()
-	if err != nil {
-		http.Error(w, fmt.Sprintf("error: %s", err), 500)
-	}
-
-	formBackupPath := r.Form.Get("backuppath")
-
-	// always backup so that we can roll back to the previous version if
-	// migration fails
-	backupPath := formBackupPath
-	if formBackupPath == "" {
-		backupPath = database.DatabaseBackupPath()
-	}
-
-	// perform database backup
-	if err = database.Backup(backupPath); err != nil {
-		http.Error(w, fmt.Sprintf("error backing up database: %s", err), 500)
-		return
-	}
-
-	err = database.RunMigrations()
-	if err != nil {
-		errStr := fmt.Sprintf("error performing migration: %s", err)
-
-		// roll back to the backed up version
-		restoreErr := database.RestoreFromBackup(backupPath)
-		if restoreErr != nil {
-			errStr = fmt.Sprintf("ERROR: unable to restore database from backup after migration failure: %s\n%s", restoreErr.Error(), errStr)
-		} else {
-			errStr = "An error occurred migrating the database to the latest schema version. The backup database file was automatically renamed to restore the database.\n" + errStr
-		}
-
-		http.Error(w, errStr, 500)
-		return
-	}
-
-	// perform post-migration operations
-	manager.GetInstance().PostMigrate()
-
-	// if no backup path was provided, then delete the created backup
-	if formBackupPath == "" {
-		err = os.Remove(backupPath)
-		if err != nil {
-			logger.Warnf("error removing unwanted database backup (%s): %s", backupPath, err.Error())
-		}
-	}
-
-	http.Redirect(w, r, "/", 301)
-}

pkg/api/resolver.go

@@ -5,12 +5,19 @@ import (
 	"sort"
 	"strconv"
 
-	"github.com/99designs/gqlgen/graphql"
 	"github.com/stashapp/stash/pkg/logger"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/plugin"
 )
 
-type Resolver struct{}
+type hookExecutor interface {
+	ExecutePostHooks(ctx context.Context, id int, hookType plugin.HookTriggerEnum, input interface{}, inputFields []string)
+}
+
+type Resolver struct {
+	txnManager   models.TransactionManager
+	hookExecutor hookExecutor
+}
 
 func (r *Resolver) Gallery() models.GalleryResolver {
 	return &galleryResolver{r}
@@ -79,69 +86,86 @@ type scrapedSceneMovieResolver struct{ *Resolver }
 type scrapedScenePerformerResolver struct{ *Resolver }
 type scrapedSceneStudioResolver struct{ *Resolver }
 
-func (r *queryResolver) MarkerWall(ctx context.Context, q *string) ([]*models.SceneMarker, error) {
-	qb := models.NewSceneMarkerQueryBuilder()
-	return qb.Wall(q)
+func (r *Resolver) withTxn(ctx context.Context, fn func(r models.Repository) error) error {
+	return r.txnManager.WithTxn(ctx, fn)
 }
 
-func (r *queryResolver) SceneWall(ctx context.Context, q *string) ([]*models.Scene, error) {
-	qb := models.NewSceneQueryBuilder()
-	return qb.Wall(q)
+func (r *Resolver) withReadTxn(ctx context.Context, fn func(r models.ReaderRepository) error) error {
+	return r.txnManager.WithReadTxn(ctx, fn)
 }
 
-func (r *queryResolver) MarkerStrings(ctx context.Context, q *string, sort *string) ([]*models.MarkerStringsResultType, error) {
-	qb := models.NewSceneMarkerQueryBuilder()
-	return qb.GetMarkerStrings(q, sort)
-}
-
-func (r *queryResolver) ValidGalleriesForScene(ctx context.Context, scene_id *string) ([]*models.Gallery, error) {
-	if scene_id == nil {
-		panic("nil scene id") // TODO make scene_id mandatory
+func (r *queryResolver) MarkerWall(ctx context.Context, q *string) (ret []*models.SceneMarker, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.SceneMarker().Wall(q)
+		return err
+	}); err != nil {
+		return nil, err
 	}
-	sceneID, _ := strconv.Atoi(*scene_id)
-	sqb := models.NewSceneQueryBuilder()
-	scene, err := sqb.Find(sceneID)
-	if err != nil {
+	return ret, nil
+}
+
+func (r *queryResolver) SceneWall(ctx context.Context, q *string) (ret []*models.Scene, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Scene().Wall(q)
+		return err
+	}); err != nil {
 		return nil, err
 	}
 
-	qb := models.NewGalleryQueryBuilder()
-	validGalleries, err := qb.ValidGalleriesForScenePath(scene.Path)
-	sceneGallery, _ := qb.FindBySceneID(sceneID, nil)
-	if sceneGallery != nil {
-		validGalleries = append(validGalleries, sceneGallery)
+	return ret, nil
+}
+
+func (r *queryResolver) MarkerStrings(ctx context.Context, q *string, sort *string) (ret []*models.MarkerStringsResultType, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.SceneMarker().GetMarkerStrings(q, sort)
+		return err
+	}); err != nil {
+		return nil, err
 	}
-	return validGalleries, nil
+
+	return ret, nil
 }
 
 func (r *queryResolver) Stats(ctx context.Context) (*models.StatsResultType, error) {
-	scenesQB := models.NewSceneQueryBuilder()
-	scenesCount, _ := scenesQB.Count()
-	scenesSize, _ := scenesQB.Size()
-	imageQB := models.NewImageQueryBuilder()
-	imageCount, _ := imageQB.Count()
-	imageSize, _ := imageQB.Size()
-	galleryQB := models.NewGalleryQueryBuilder()
-	galleryCount, _ := galleryQB.Count()
-	performersQB := models.NewPerformerQueryBuilder()
-	performersCount, _ := performersQB.Count()
-	studiosQB := models.NewStudioQueryBuilder()
-	studiosCount, _ := studiosQB.Count()
-	moviesQB := models.NewMovieQueryBuilder()
-	moviesCount, _ := moviesQB.Count()
-	tagsQB := models.NewTagQueryBuilder()
-	tagsCount, _ := tagsQB.Count()
-	return &models.StatsResultType{
-		SceneCount:     scenesCount,
-		ScenesSize:     int(scenesSize),
-		ImageCount:     imageCount,
-		ImagesSize:     int(imageSize),
-		GalleryCount:   galleryCount,
-		PerformerCount: performersCount,
-		StudioCount:    studiosCount,
-		MovieCount:     moviesCount,
-		TagCount:       tagsCount,
-	}, nil
+	var ret models.StatsResultType
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		scenesQB := repo.Scene()
+		imageQB := repo.Image()
+		galleryQB := repo.Gallery()
+		studiosQB := repo.Studio()
+		performersQB := repo.Performer()
+		moviesQB := repo.Movie()
+		tagsQB := repo.Tag()
+		scenesCount, _ := scenesQB.Count()
+		scenesSize, _ := scenesQB.Size()
+		scenesDuration, _ := scenesQB.Duration()
+		imageCount, _ := imageQB.Count()
+		imageSize, _ := imageQB.Size()
+		galleryCount, _ := galleryQB.Count()
+		performersCount, _ := performersQB.Count()
+		studiosCount, _ := studiosQB.Count()
+		moviesCount, _ := moviesQB.Count()
+		tagsCount, _ := tagsQB.Count()
+
+		ret = models.StatsResultType{
+			SceneCount:     scenesCount,
+			ScenesSize:     scenesSize,
+			ScenesDuration: scenesDuration,
+			ImageCount:     imageCount,
+			ImagesSize:     imageSize,
+			GalleryCount:   galleryCount,
+			PerformerCount: performersCount,
+			StudioCount:    studiosCount,
+			MovieCount:     moviesCount,
+			TagCount:       tagsCount,
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	return &ret, nil
 }
 
 func (r *queryResolver) Version(ctx context.Context) (*models.Version, error) {
@@ -171,31 +195,38 @@ func (r *queryResolver) Latestversion(ctx context.Context) (*models.ShortVersion
 
 // Get scene marker tags which show up under the video.
 func (r *queryResolver) SceneMarkerTags(ctx context.Context, scene_id string) ([]*models.SceneMarkerTag, error) {
-	sceneID, _ := strconv.Atoi(scene_id)
-	sqb := models.NewSceneMarkerQueryBuilder()
-	sceneMarkers, err := sqb.FindBySceneID(sceneID, nil)
+	sceneID, err := strconv.Atoi(scene_id)
 	if err != nil {
 		return nil, err
 	}
 
-	tags := make(map[int]*models.SceneMarkerTag)
 	var keys []int
-	tqb := models.NewTagQueryBuilder()
-	for _, sceneMarker := range sceneMarkers {
-		markerPrimaryTag, err := tqb.Find(sceneMarker.PrimaryTagID, nil)
+	tags := make(map[int]*models.SceneMarkerTag)
+
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		sceneMarkers, err := repo.SceneMarker().FindBySceneID(sceneID)
 		if err != nil {
-			return nil, err
+			return err
 		}
-		_, hasKey := tags[markerPrimaryTag.ID]
-		var sceneMarkerTag *models.SceneMarkerTag
-		if !hasKey {
-			sceneMarkerTag = &models.SceneMarkerTag{Tag: markerPrimaryTag}
-			tags[markerPrimaryTag.ID] = sceneMarkerTag
-			keys = append(keys, markerPrimaryTag.ID)
-		} else {
-			sceneMarkerTag = tags[markerPrimaryTag.ID]
+
+		tqb := repo.Tag()
+		for _, sceneMarker := range sceneMarkers {
+			markerPrimaryTag, err := tqb.Find(sceneMarker.PrimaryTagID)
+			if err != nil {
+				return err
+			}
+			_, hasKey := tags[markerPrimaryTag.ID]
+			if !hasKey {
+				sceneMarkerTag := &models.SceneMarkerTag{Tag: markerPrimaryTag}
+				tags[markerPrimaryTag.ID] = sceneMarkerTag
+				keys = append(keys, markerPrimaryTag.ID)
+			}
+			tags[markerPrimaryTag.ID].SceneMarkers = append(tags[markerPrimaryTag.ID].SceneMarkers, sceneMarker)
 		}
-		tags[markerPrimaryTag.ID].SceneMarkers = append(tags[markerPrimaryTag.ID].SceneMarkers, sceneMarker)
+
+		return nil
+	}); err != nil {
+		return nil, err
 	}
 
 	// Sort so that primary tags that show up earlier in the video are first.
@@ -212,13 +243,3 @@ func (r *queryResolver) SceneMarkerTags(ctx context.Context, scene_id string) ([
 
 	return result, nil
 }
-
-// wasFieldIncluded returns true if the given field was included in the request.
-// Slices are unmarshalled to empty slices even if the field was omitted. This
-// method determines if it was omitted altogether.
-func wasFieldIncluded(ctx context.Context, field string) bool {
-	rctx := graphql.GetRequestContext(ctx)
-
-	_, ret := rctx.Variables[field]
-	return ret
-}

pkg/api/resolver_model_gallery.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/image"
 	"github.com/stashapp/stash/pkg/models"
@@ -22,30 +23,39 @@ func (r *galleryResolver) Title(ctx context.Context, obj *models.Gallery) (*stri
 	return nil, nil
 }
 
-func (r *galleryResolver) Images(ctx context.Context, obj *models.Gallery) ([]*models.Image, error) {
-	qb := models.NewImageQueryBuilder()
-
-	return qb.FindByGalleryID(obj.ID)
-}
-
-func (r *galleryResolver) Cover(ctx context.Context, obj *models.Gallery) (*models.Image, error) {
-	qb := models.NewImageQueryBuilder()
-
-	imgs, err := qb.FindByGalleryID(obj.ID)
-	if err != nil {
+func (r *galleryResolver) Images(ctx context.Context, obj *models.Gallery) (ret []*models.Image, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Image().FindByGalleryID(obj.ID)
+		return err
+	}); err != nil {
 		return nil, err
 	}
 
-	var ret *models.Image
-	if len(imgs) > 0 {
-		ret = imgs[0]
-	}
+	return ret, nil
+}
 
-	for _, img := range imgs {
-		if image.IsCover(img) {
-			ret = img
-			break
+func (r *galleryResolver) Cover(ctx context.Context, obj *models.Gallery) (ret *models.Image, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		imgs, err := repo.Image().FindByGalleryID(obj.ID)
+		if err != nil {
+			return err
 		}
+
+		if len(imgs) > 0 {
+			ret = imgs[0]
+		}
+
+		for _, img := range imgs {
+			if image.IsCover(img) {
+				ret = img
+				break
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
 	}
 
 	return ret, nil
@@ -81,35 +91,78 @@ func (r *galleryResolver) Rating(ctx context.Context, obj *models.Gallery) (*int
 	return nil, nil
 }
 
-func (r *galleryResolver) Scene(ctx context.Context, obj *models.Gallery) (*models.Scene, error) {
-	if !obj.SceneID.Valid {
-		return nil, nil
+func (r *galleryResolver) Scenes(ctx context.Context, obj *models.Gallery) (ret []*models.Scene, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Scene().FindByGalleryID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
 	}
 
-	qb := models.NewSceneQueryBuilder()
-	return qb.Find(int(obj.SceneID.Int64))
+	return ret, nil
 }
 
-func (r *galleryResolver) Studio(ctx context.Context, obj *models.Gallery) (*models.Studio, error) {
+func (r *galleryResolver) Studio(ctx context.Context, obj *models.Gallery) (ret *models.Studio, err error) {
 	if !obj.StudioID.Valid {
 		return nil, nil
 	}
 
-	qb := models.NewStudioQueryBuilder()
-	return qb.Find(int(obj.StudioID.Int64), nil)
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Studio().Find(int(obj.StudioID.Int64))
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *galleryResolver) Tags(ctx context.Context, obj *models.Gallery) ([]*models.Tag, error) {
-	qb := models.NewTagQueryBuilder()
-	return qb.FindByGalleryID(obj.ID, nil)
+func (r *galleryResolver) Tags(ctx context.Context, obj *models.Gallery) (ret []*models.Tag, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Tag().FindByGalleryID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *galleryResolver) Performers(ctx context.Context, obj *models.Gallery) ([]*models.Performer, error) {
-	qb := models.NewPerformerQueryBuilder()
-	return qb.FindByGalleryID(obj.ID, nil)
+func (r *galleryResolver) Performers(ctx context.Context, obj *models.Gallery) (ret []*models.Performer, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Performer().FindByGalleryID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *galleryResolver) ImageCount(ctx context.Context, obj *models.Gallery) (int, error) {
-	qb := models.NewImageQueryBuilder()
-	return qb.CountByGalleryID(obj.ID)
+func (r *galleryResolver) ImageCount(ctx context.Context, obj *models.Gallery) (ret int, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Image().CountByGalleryID(obj.ID)
+		return err
+	}); err != nil {
+		return 0, err
+	}
+
+	return ret, nil
+}
+
+func (r *galleryResolver) CreatedAt(ctx context.Context, obj *models.Gallery) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *galleryResolver) UpdatedAt(ctx context.Context, obj *models.Gallery) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
+}
+
+func (r *galleryResolver) FileModTime(ctx context.Context, obj *models.Gallery) (*time.Time, error) {
+	return &obj.FileModTime.Timestamp, nil
 }

pkg/api/resolver_model_image.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
 	"github.com/stashapp/stash/pkg/image"
@@ -34,7 +35,7 @@ func (r *imageResolver) File(ctx context.Context, obj *models.Image) (*models.Im
 
 func (r *imageResolver) Paths(ctx context.Context, obj *models.Image) (*models.ImagePathsType, error) {
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
-	builder := urlbuilders.NewImageURLBuilder(baseURL, obj.ID)
+	builder := urlbuilders.NewImageURLBuilder(baseURL, obj)
 	thumbnailPath := builder.GetThumbnailURL()
 	imagePath := builder.GetImageURL()
 	return &models.ImagePathsType{
@@ -43,26 +44,63 @@ func (r *imageResolver) Paths(ctx context.Context, obj *models.Image) (*models.I
 	}, nil
 }
 
-func (r *imageResolver) Galleries(ctx context.Context, obj *models.Image) ([]*models.Gallery, error) {
-	qb := models.NewGalleryQueryBuilder()
-	return qb.FindByImageID(obj.ID, nil)
+func (r *imageResolver) Galleries(ctx context.Context, obj *models.Image) (ret []*models.Gallery, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		ret, err = repo.Gallery().FindByImageID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *imageResolver) Studio(ctx context.Context, obj *models.Image) (*models.Studio, error) {
+func (r *imageResolver) Studio(ctx context.Context, obj *models.Image) (ret *models.Studio, err error) {
 	if !obj.StudioID.Valid {
 		return nil, nil
 	}
 
-	qb := models.NewStudioQueryBuilder()
-	return qb.Find(int(obj.StudioID.Int64), nil)
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Studio().Find(int(obj.StudioID.Int64))
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *imageResolver) Tags(ctx context.Context, obj *models.Image) ([]*models.Tag, error) {
-	qb := models.NewTagQueryBuilder()
-	return qb.FindByImageID(obj.ID, nil)
+func (r *imageResolver) Tags(ctx context.Context, obj *models.Image) (ret []*models.Tag, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Tag().FindByImageID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *imageResolver) Performers(ctx context.Context, obj *models.Image) ([]*models.Performer, error) {
-	qb := models.NewPerformerQueryBuilder()
-	return qb.FindByImageID(obj.ID, nil)
+func (r *imageResolver) Performers(ctx context.Context, obj *models.Image) (ret []*models.Performer, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Performer().FindByImageID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *imageResolver) CreatedAt(ctx context.Context, obj *models.Image) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *imageResolver) UpdatedAt(ctx context.Context, obj *models.Image) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
+}
+
+func (r *imageResolver) FileModTime(ctx context.Context, obj *models.Image) (*time.Time, error) {
+	return &obj.FileModTime.Timestamp, nil
 }

pkg/api/resolver_model_movie.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
 	"github.com/stashapp/stash/pkg/models"
@@ -53,10 +54,16 @@ func (r *movieResolver) Rating(ctx context.Context, obj *models.Movie) (*int, er
 	return nil, nil
 }
 
-func (r *movieResolver) Studio(ctx context.Context, obj *models.Movie) (*models.Studio, error) {
-	qb := models.NewStudioQueryBuilder()
+func (r *movieResolver) Studio(ctx context.Context, obj *models.Movie) (ret *models.Studio, err error) {
 	if obj.StudioID.Valid {
-		return qb.Find(int(obj.StudioID.Int64), nil)
+		if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+			ret, err = repo.Studio().Find(int(obj.StudioID.Int64))
+			return err
+		}); err != nil {
+			return nil, err
+		}
+
+		return ret, nil
 	}
 
 	return nil, nil
@@ -78,18 +85,50 @@ func (r *movieResolver) Synopsis(ctx context.Context, obj *models.Movie) (*strin
 
 func (r *movieResolver) FrontImagePath(ctx context.Context, obj *models.Movie) (*string, error) {
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
-	frontimagePath := urlbuilders.NewMovieURLBuilder(baseURL, obj.ID).GetMovieFrontImageURL()
+	frontimagePath := urlbuilders.NewMovieURLBuilder(baseURL, obj).GetMovieFrontImageURL()
 	return &frontimagePath, nil
 }
 
 func (r *movieResolver) BackImagePath(ctx context.Context, obj *models.Movie) (*string, error) {
+	// don't return any thing if there is no back image
+	var img []byte
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		img, err = repo.Movie().GetBackImage(obj.ID)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	if img == nil {
+		return nil, nil
+	}
+
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
-	backimagePath := urlbuilders.NewMovieURLBuilder(baseURL, obj.ID).GetMovieBackImageURL()
+	backimagePath := urlbuilders.NewMovieURLBuilder(baseURL, obj).GetMovieBackImageURL()
 	return &backimagePath, nil
 }
 
-func (r *movieResolver) SceneCount(ctx context.Context, obj *models.Movie) (*int, error) {
-	qb := models.NewSceneQueryBuilder()
-	res, err := qb.CountByMovieID(obj.ID)
+func (r *movieResolver) SceneCount(ctx context.Context, obj *models.Movie) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = repo.Scene().CountByMovieID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
 	return &res, err
 }
+
+func (r *movieResolver) CreatedAt(ctx context.Context, obj *models.Movie) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *movieResolver) UpdatedAt(ctx context.Context, obj *models.Movie) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
+}

pkg/api/resolver_model_performer.go

@@ -2,8 +2,11 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
+	"github.com/stashapp/stash/pkg/gallery"
+	"github.com/stashapp/stash/pkg/image"
 	"github.com/stashapp/stash/pkg/models"
 )
 
@@ -134,22 +137,120 @@ func (r *performerResolver) Favorite(ctx context.Context, obj *models.Performer)
 
 func (r *performerResolver) ImagePath(ctx context.Context, obj *models.Performer) (*string, error) {
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
-	imagePath := urlbuilders.NewPerformerURLBuilder(baseURL, obj.ID).GetPerformerImageURL()
+	imagePath := urlbuilders.NewPerformerURLBuilder(baseURL, obj).GetPerformerImageURL()
 	return &imagePath, nil
 }
 
-func (r *performerResolver) SceneCount(ctx context.Context, obj *models.Performer) (*int, error) {
-	qb := models.NewSceneQueryBuilder()
-	res, err := qb.CountByPerformerID(obj.ID)
-	return &res, err
+func (r *performerResolver) Tags(ctx context.Context, obj *models.Performer) (ret []*models.Tag, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Tag().FindByPerformerID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *performerResolver) Scenes(ctx context.Context, obj *models.Performer) ([]*models.Scene, error) {
-	qb := models.NewSceneQueryBuilder()
-	return qb.FindByPerformerID(obj.ID)
+func (r *performerResolver) SceneCount(ctx context.Context, obj *models.Performer) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = repo.Scene().CountByPerformerID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
 }
 
-func (r *performerResolver) StashIds(ctx context.Context, obj *models.Performer) ([]*models.StashID, error) {
-	qb := models.NewJoinsQueryBuilder()
-	return qb.GetPerformerStashIDs(obj.ID)
+func (r *performerResolver) ImageCount(ctx context.Context, obj *models.Performer) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = image.CountByPerformerID(repo.Image(), obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (r *performerResolver) GalleryCount(ctx context.Context, obj *models.Performer) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = gallery.CountByPerformerID(repo.Gallery(), obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (r *performerResolver) Scenes(ctx context.Context, obj *models.Performer) (ret []*models.Scene, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Scene().FindByPerformerID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *performerResolver) StashIds(ctx context.Context, obj *models.Performer) (ret []*models.StashID, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Performer().GetStashIDs(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *performerResolver) Rating(ctx context.Context, obj *models.Performer) (*int, error) {
+	if obj.Rating.Valid {
+		rating := int(obj.Rating.Int64)
+		return &rating, nil
+	}
+	return nil, nil
+}
+
+func (r *performerResolver) Details(ctx context.Context, obj *models.Performer) (*string, error) {
+	if obj.Details.Valid {
+		return &obj.Details.String, nil
+	}
+	return nil, nil
+}
+
+func (r *performerResolver) DeathDate(ctx context.Context, obj *models.Performer) (*string, error) {
+	if obj.DeathDate.Valid {
+		return &obj.DeathDate.String, nil
+	}
+	return nil, nil
+}
+
+func (r *performerResolver) HairColor(ctx context.Context, obj *models.Performer) (*string, error) {
+	if obj.HairColor.Valid {
+		return &obj.HairColor.String, nil
+	}
+	return nil, nil
+}
+
+func (r *performerResolver) Weight(ctx context.Context, obj *models.Performer) (*int, error) {
+	if obj.Weight.Valid {
+		weight := int(obj.Weight.Int64)
+		return &weight, nil
+	}
+	return nil, nil
+}
+
+func (r *performerResolver) CreatedAt(ctx context.Context, obj *models.Performer) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *performerResolver) UpdatedAt(ctx context.Context, obj *models.Performer) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
 }

pkg/api/resolver_model_scene.go

@@ -2,8 +2,10 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
+	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/models"
 	"github.com/stashapp/stash/pkg/utils"
 )
@@ -65,12 +67,12 @@ func (r *sceneResolver) File(ctx context.Context, obj *models.Scene) (*models.Sc
 	bitrate := int(obj.Bitrate.Int64)
 	return &models.SceneFileType{
 		Size:       &obj.Size.String,
-		Duration:   &obj.Duration.Float64,
+		Duration:   handleFloat64(obj.Duration.Float64),
 		VideoCodec: &obj.VideoCodec.String,
 		AudioCodec: &obj.AudioCodec.String,
 		Width:      &width,
 		Height:     &height,
-		Framerate:  &obj.Framerate.Float64,
+		Framerate:  handleFloat64(obj.Framerate.Float64),
 		Bitrate:    &bitrate,
 	}, nil
 }
@@ -78,12 +80,16 @@ func (r *sceneResolver) File(ctx context.Context, obj *models.Scene) (*models.Sc
 func (r *sceneResolver) Paths(ctx context.Context, obj *models.Scene) (*models.ScenePathsType, error) {
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
 	builder := urlbuilders.NewSceneURLBuilder(baseURL, obj.ID)
+	builder.APIKey = config.GetInstance().GetAPIKey()
 	screenshotPath := builder.GetScreenshotURL(obj.UpdatedAt.Timestamp)
 	previewPath := builder.GetStreamPreviewURL()
 	streamPath := builder.GetStreamURL()
 	webpPath := builder.GetStreamPreviewImageURL()
 	vttPath := builder.GetSpriteVTTURL()
+	spritePath := builder.GetSpriteURL()
 	chaptersVttPath := builder.GetChaptersVTTURL()
+	funscriptPath := builder.GetFunscriptURL()
+
 	return &models.ScenePathsType{
 		Screenshot:  &screenshotPath,
 		Preview:     &previewPath,
@@ -91,67 +97,133 @@ func (r *sceneResolver) Paths(ctx context.Context, obj *models.Scene) (*models.S
 		Webp:        &webpPath,
 		Vtt:         &vttPath,
 		ChaptersVtt: &chaptersVttPath,
+		Sprite:      &spritePath,
+		Funscript:   &funscriptPath,
 	}, nil
 }
 
-func (r *sceneResolver) SceneMarkers(ctx context.Context, obj *models.Scene) ([]*models.SceneMarker, error) {
-	qb := models.NewSceneMarkerQueryBuilder()
-	return qb.FindBySceneID(obj.ID, nil)
-}
-
-func (r *sceneResolver) Gallery(ctx context.Context, obj *models.Scene) (*models.Gallery, error) {
-	qb := models.NewGalleryQueryBuilder()
-	return qb.FindBySceneID(obj.ID, nil)
-}
-
-func (r *sceneResolver) Studio(ctx context.Context, obj *models.Scene) (*models.Studio, error) {
-	qb := models.NewStudioQueryBuilder()
-	return qb.FindBySceneID(obj.ID)
-}
-
-func (r *sceneResolver) Movies(ctx context.Context, obj *models.Scene) ([]*models.SceneMovie, error) {
-	joinQB := models.NewJoinsQueryBuilder()
-	qb := models.NewMovieQueryBuilder()
-
-	sceneMovies, err := joinQB.GetSceneMovies(obj.ID, nil)
-	if err != nil {
+func (r *sceneResolver) SceneMarkers(ctx context.Context, obj *models.Scene) (ret []*models.SceneMarker, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.SceneMarker().FindBySceneID(obj.ID)
+		return err
+	}); err != nil {
 		return nil, err
 	}
 
-	var ret []*models.SceneMovie
-	for _, sm := range sceneMovies {
-		movie, err := qb.Find(sm.MovieID, nil)
+	return ret, nil
+}
+
+func (r *sceneResolver) Galleries(ctx context.Context, obj *models.Scene) (ret []*models.Gallery, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Gallery().FindBySceneID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *sceneResolver) Studio(ctx context.Context, obj *models.Scene) (ret *models.Studio, err error) {
+	if !obj.StudioID.Valid {
+		return nil, nil
+	}
+
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Studio().Find(int(obj.StudioID.Int64))
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *sceneResolver) Movies(ctx context.Context, obj *models.Scene) (ret []*models.SceneMovie, err error) {
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Scene()
+		mqb := repo.Movie()
+
+		sceneMovies, err := qb.GetMovies(obj.ID)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
-		sceneIdx := sm.SceneIndex
-		sceneMovie := &models.SceneMovie{
-			Movie: movie,
+		for _, sm := range sceneMovies {
+			movie, err := mqb.Find(sm.MovieID)
+			if err != nil {
+				return err
+			}
+
+			sceneIdx := sm.SceneIndex
+			sceneMovie := &models.SceneMovie{
+				Movie: movie,
+			}
+
+			if sceneIdx.Valid {
+				idx := int(sceneIdx.Int64)
+				sceneMovie.SceneIndex = &idx
+			}
+
+			ret = append(ret, sceneMovie)
 		}
 
-		if sceneIdx.Valid {
-			var idx int
-			idx = int(sceneIdx.Int64)
-			sceneMovie.SceneIndex = &idx
-		}
-
-		ret = append(ret, sceneMovie)
+		return nil
+	}); err != nil {
+		return nil, err
 	}
 	return ret, nil
 }
 
-func (r *sceneResolver) Tags(ctx context.Context, obj *models.Scene) ([]*models.Tag, error) {
-	qb := models.NewTagQueryBuilder()
-	return qb.FindBySceneID(obj.ID, nil)
+func (r *sceneResolver) Tags(ctx context.Context, obj *models.Scene) (ret []*models.Tag, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Tag().FindBySceneID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *sceneResolver) Performers(ctx context.Context, obj *models.Scene) ([]*models.Performer, error) {
-	qb := models.NewPerformerQueryBuilder()
-	return qb.FindBySceneID(obj.ID, nil)
+func (r *sceneResolver) Performers(ctx context.Context, obj *models.Scene) (ret []*models.Performer, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Performer().FindBySceneID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *sceneResolver) StashIds(ctx context.Context, obj *models.Scene) ([]*models.StashID, error) {
-	qb := models.NewJoinsQueryBuilder()
-	return qb.GetSceneStashIDs(obj.ID)
+func (r *sceneResolver) StashIds(ctx context.Context, obj *models.Scene) (ret []*models.StashID, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Scene().GetStashIDs(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *sceneResolver) Phash(ctx context.Context, obj *models.Scene) (*string, error) {
+	if obj.Phash.Valid {
+		hexval := utils.PhashToString(obj.Phash.Int64)
+		return &hexval, nil
+	}
+	return nil, nil
+}
+
+func (r *sceneResolver) CreatedAt(ctx context.Context, obj *models.Scene) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *sceneResolver) UpdatedAt(ctx context.Context, obj *models.Scene) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
+}
+
+func (r *sceneResolver) FileModTime(ctx context.Context, obj *models.Scene) (*time.Time, error) {
+	return &obj.FileModTime.Timestamp, nil
 }

pkg/api/resolver_model_scene_marker.go

@@ -2,29 +2,48 @@ package api
 
 import (
 	"context"
+	"time"
+
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
 	"github.com/stashapp/stash/pkg/models"
 )
 
-func (r *sceneMarkerResolver) Scene(ctx context.Context, obj *models.SceneMarker) (*models.Scene, error) {
+func (r *sceneMarkerResolver) Scene(ctx context.Context, obj *models.SceneMarker) (ret *models.Scene, err error) {
 	if !obj.SceneID.Valid {
 		panic("Invalid scene id")
 	}
-	qb := models.NewSceneQueryBuilder()
-	sceneID := int(obj.SceneID.Int64)
-	scene, err := qb.Find(sceneID)
-	return scene, err
+
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		sceneID := int(obj.SceneID.Int64)
+		ret, err = repo.Scene().Find(sceneID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *sceneMarkerResolver) PrimaryTag(ctx context.Context, obj *models.SceneMarker) (*models.Tag, error) {
-	qb := models.NewTagQueryBuilder()
-	tag, err := qb.Find(obj.PrimaryTagID, nil)
-	return tag, err
+func (r *sceneMarkerResolver) PrimaryTag(ctx context.Context, obj *models.SceneMarker) (ret *models.Tag, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Tag().Find(obj.PrimaryTagID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, err
 }
 
-func (r *sceneMarkerResolver) Tags(ctx context.Context, obj *models.SceneMarker) ([]*models.Tag, error) {
-	qb := models.NewTagQueryBuilder()
-	return qb.FindBySceneMarkerID(obj.ID, nil)
+func (r *sceneMarkerResolver) Tags(ctx context.Context, obj *models.SceneMarker) (ret []*models.Tag, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Tag().FindBySceneMarkerID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, err
 }
 
 func (r *sceneMarkerResolver) Stream(ctx context.Context, obj *models.SceneMarker) (string, error) {
@@ -38,3 +57,11 @@ func (r *sceneMarkerResolver) Preview(ctx context.Context, obj *models.SceneMark
 	sceneID := int(obj.SceneID.Int64)
 	return urlbuilders.NewSceneURLBuilder(baseURL, sceneID).GetSceneMarkerStreamPreviewURL(obj.ID), nil
 }
+
+func (r *sceneMarkerResolver) CreatedAt(ctx context.Context, obj *models.SceneMarker) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *sceneMarkerResolver) UpdatedAt(ctx context.Context, obj *models.SceneMarker) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
+}

pkg/api/resolver_model_studio.go

@@ -2,8 +2,11 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
+	"github.com/stashapp/stash/pkg/gallery"
+	"github.com/stashapp/stash/pkg/image"
 	"github.com/stashapp/stash/pkg/models"
 )
 
@@ -23,31 +26,117 @@ func (r *studioResolver) URL(ctx context.Context, obj *models.Studio) (*string,
 
 func (r *studioResolver) ImagePath(ctx context.Context, obj *models.Studio) (*string, error) {
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
-	imagePath := urlbuilders.NewStudioURLBuilder(baseURL, obj.ID).GetStudioImageURL()
+	imagePath := urlbuilders.NewStudioURLBuilder(baseURL, obj).GetStudioImageURL()
+
+	var hasImage bool
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		var err error
+		hasImage, err = repo.Studio().HasImage(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	// indicate that image is missing by setting default query param to true
+	if !hasImage {
+		imagePath = imagePath + "?default=true"
+	}
+
 	return &imagePath, nil
 }
 
-func (r *studioResolver) SceneCount(ctx context.Context, obj *models.Studio) (*int, error) {
-	qb := models.NewSceneQueryBuilder()
-	res, err := qb.CountByStudioID(obj.ID)
+func (r *studioResolver) SceneCount(ctx context.Context, obj *models.Studio) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = repo.Scene().CountByStudioID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
 	return &res, err
 }
 
-func (r *studioResolver) ParentStudio(ctx context.Context, obj *models.Studio) (*models.Studio, error) {
+func (r *studioResolver) ImageCount(ctx context.Context, obj *models.Studio) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = image.CountByStudioID(repo.Image(), obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (r *studioResolver) GalleryCount(ctx context.Context, obj *models.Studio) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = gallery.CountByStudioID(repo.Gallery(), obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (r *studioResolver) ParentStudio(ctx context.Context, obj *models.Studio) (ret *models.Studio, err error) {
 	if !obj.ParentID.Valid {
 		return nil, nil
 	}
 
-	qb := models.NewStudioQueryBuilder()
-	return qb.Find(int(obj.ParentID.Int64), nil)
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Studio().Find(int(obj.ParentID.Int64))
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *studioResolver) ChildStudios(ctx context.Context, obj *models.Studio) ([]*models.Studio, error) {
-	qb := models.NewStudioQueryBuilder()
-	return qb.FindChildren(obj.ID, nil)
+func (r *studioResolver) ChildStudios(ctx context.Context, obj *models.Studio) (ret []*models.Studio, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Studio().FindChildren(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
 }
 
-func (r *studioResolver) StashIds(ctx context.Context, obj *models.Studio) ([]*models.StashID, error) {
-	qb := models.NewJoinsQueryBuilder()
-	return qb.GetStudioStashIDs(obj.ID)
+func (r *studioResolver) StashIds(ctx context.Context, obj *models.Studio) (ret []*models.StashID, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Studio().GetStashIDs(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (r *studioResolver) Rating(ctx context.Context, obj *models.Studio) (*int, error) {
+	if obj.Rating.Valid {
+		rating := int(obj.Rating.Int64)
+		return &rating, nil
+	}
+	return nil, nil
+}
+
+func (r *studioResolver) Details(ctx context.Context, obj *models.Studio) (*string, error) {
+	if obj.Details.Valid {
+		return &obj.Details.String, nil
+	}
+	return nil, nil
+}
+
+func (r *studioResolver) CreatedAt(ctx context.Context, obj *models.Studio) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *studioResolver) UpdatedAt(ctx context.Context, obj *models.Studio) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
 }

pkg/api/resolver_model_tag.go

@@ -2,31 +2,95 @@ package api
 
 import (
 	"context"
+	"time"
 
 	"github.com/stashapp/stash/pkg/api/urlbuilders"
+	"github.com/stashapp/stash/pkg/gallery"
+	"github.com/stashapp/stash/pkg/image"
 	"github.com/stashapp/stash/pkg/models"
 )
 
-func (r *tagResolver) SceneCount(ctx context.Context, obj *models.Tag) (*int, error) {
-	qb := models.NewSceneQueryBuilder()
-	if obj == nil {
-		return nil, nil
+func (r *tagResolver) Aliases(ctx context.Context, obj *models.Tag) (ret []string, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Tag().GetAliases(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
 	}
-	count, err := qb.CountByTagID(obj.ID)
+
+	return ret, err
+}
+
+func (r *tagResolver) SceneCount(ctx context.Context, obj *models.Tag) (ret *int, err error) {
+	var count int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		count, err = repo.Scene().CountByTagID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
 	return &count, err
 }
 
-func (r *tagResolver) SceneMarkerCount(ctx context.Context, obj *models.Tag) (*int, error) {
-	qb := models.NewSceneMarkerQueryBuilder()
-	if obj == nil {
-		return nil, nil
+func (r *tagResolver) SceneMarkerCount(ctx context.Context, obj *models.Tag) (ret *int, err error) {
+	var count int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		count, err = repo.SceneMarker().CountByTagID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
 	}
-	count, err := qb.CountByTagID(obj.ID)
+
+	return &count, err
+}
+
+func (r *tagResolver) ImageCount(ctx context.Context, obj *models.Tag) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = image.CountByTagID(repo.Image(), obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (r *tagResolver) GalleryCount(ctx context.Context, obj *models.Tag) (ret *int, err error) {
+	var res int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		res, err = gallery.CountByTagID(repo.Gallery(), obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (r *tagResolver) PerformerCount(ctx context.Context, obj *models.Tag) (ret *int, err error) {
+	var count int
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		count, err = repo.Performer().CountByTagID(obj.ID)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
 	return &count, err
 }
 
 func (r *tagResolver) ImagePath(ctx context.Context, obj *models.Tag) (*string, error) {
 	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
-	imagePath := urlbuilders.NewTagURLBuilder(baseURL, obj.ID).GetTagImageURL()
+	imagePath := urlbuilders.NewTagURLBuilder(baseURL, obj).GetTagImageURL()
 	return &imagePath, nil
 }
+
+func (r *tagResolver) CreatedAt(ctx context.Context, obj *models.Tag) (*time.Time, error) {
+	return &obj.CreatedAt.Timestamp, nil
+}
+
+func (r *tagResolver) UpdatedAt(ctx context.Context, obj *models.Tag) (*time.Time, error) {
+	return &obj.UpdatedAt.Timestamp, nil
+}

pkg/api/resolver_mutation_configure.go

@@ -13,15 +13,37 @@ import (
 	"github.com/stashapp/stash/pkg/utils"
 )
 
+func (r *mutationResolver) Setup(ctx context.Context, input models.SetupInput) (bool, error) {
+	err := manager.GetInstance().Setup(input)
+	return err == nil, err
+}
+
+func (r *mutationResolver) Migrate(ctx context.Context, input models.MigrateInput) (bool, error) {
+	err := manager.GetInstance().Migrate(input)
+	return err == nil, err
+}
+
 func (r *mutationResolver) ConfigureGeneral(ctx context.Context, input models.ConfigGeneralInput) (*models.ConfigGeneralResult, error) {
+	c := config.GetInstance()
+	existingPaths := c.GetStashPaths()
 	if len(input.Stashes) > 0 {
 		for _, s := range input.Stashes {
-			exists, err := utils.DirExists(s.Path)
-			if !exists {
-				return makeConfigGeneralResult(), err
+			// Only validate existence of new paths
+			isNew := true
+			for _, path := range existingPaths {
+				if path.Path == s.Path {
+					isNew = false
+					break
+				}
+			}
+			if isNew {
+				exists, err := utils.DirExists(s.Path)
+				if !exists {
+					return makeConfigGeneralResult(), err
+				}
 			}
 		}
-		config.Set(config.Stash, input.Stashes)
+		c.Set(config.Stash, input.Stashes)
 	}
 
 	if input.DatabasePath != nil {
@@ -29,133 +51,150 @@ func (r *mutationResolver) ConfigureGeneral(ctx context.Context, input models.Co
 		if ext != ".db" && ext != ".sqlite" && ext != ".sqlite3" {
 			return makeConfigGeneralResult(), fmt.Errorf("invalid database path, use extension db, sqlite, or sqlite3")
 		}
-		config.Set(config.Database, input.DatabasePath)
+		c.Set(config.Database, input.DatabasePath)
 	}
 
 	if input.GeneratedPath != nil {
 		if err := utils.EnsureDir(*input.GeneratedPath); err != nil {
 			return makeConfigGeneralResult(), err
 		}
-		config.Set(config.Generated, input.GeneratedPath)
+		c.Set(config.Generated, input.GeneratedPath)
 	}
 
 	if input.CachePath != nil {
-		if err := utils.EnsureDir(*input.CachePath); err != nil {
-			return makeConfigGeneralResult(), err
+		if *input.CachePath != "" {
+			if err := utils.EnsureDir(*input.CachePath); err != nil {
+				return makeConfigGeneralResult(), err
+			}
 		}
-		config.Set(config.Cache, input.CachePath)
+		c.Set(config.Cache, input.CachePath)
 	}
 
 	if !input.CalculateMd5 && input.VideoFileNamingAlgorithm == models.HashAlgorithmMd5 {
 		return makeConfigGeneralResult(), errors.New("calculateMD5 must be true if using MD5")
 	}
 
-	if input.VideoFileNamingAlgorithm != config.GetVideoFileNamingAlgorithm() {
+	if input.VideoFileNamingAlgorithm != c.GetVideoFileNamingAlgorithm() {
 		// validate changing VideoFileNamingAlgorithm
-		if err := manager.ValidateVideoFileNamingAlgorithm(input.VideoFileNamingAlgorithm); err != nil {
+		if err := manager.ValidateVideoFileNamingAlgorithm(r.txnManager, input.VideoFileNamingAlgorithm); err != nil {
 			return makeConfigGeneralResult(), err
 		}
 
-		config.Set(config.VideoFileNamingAlgorithm, input.VideoFileNamingAlgorithm)
+		c.Set(config.VideoFileNamingAlgorithm, input.VideoFileNamingAlgorithm)
 	}
 
-	config.Set(config.CalculateMD5, input.CalculateMd5)
+	c.Set(config.CalculateMD5, input.CalculateMd5)
+
+	if input.ParallelTasks != nil {
+		c.Set(config.ParallelTasks, *input.ParallelTasks)
+	}
+
+	c.Set(config.PreviewAudio, input.PreviewAudio)
 
 	if input.PreviewSegments != nil {
-		config.Set(config.PreviewSegments, *input.PreviewSegments)
+		c.Set(config.PreviewSegments, *input.PreviewSegments)
 	}
 	if input.PreviewSegmentDuration != nil {
-		config.Set(config.PreviewSegmentDuration, *input.PreviewSegmentDuration)
+		c.Set(config.PreviewSegmentDuration, *input.PreviewSegmentDuration)
 	}
 	if input.PreviewExcludeStart != nil {
-		config.Set(config.PreviewExcludeStart, *input.PreviewExcludeStart)
+		c.Set(config.PreviewExcludeStart, *input.PreviewExcludeStart)
 	}
 	if input.PreviewExcludeEnd != nil {
-		config.Set(config.PreviewExcludeEnd, *input.PreviewExcludeEnd)
+		c.Set(config.PreviewExcludeEnd, *input.PreviewExcludeEnd)
 	}
 	if input.PreviewPreset != nil {
-		config.Set(config.PreviewPreset, input.PreviewPreset.String())
+		c.Set(config.PreviewPreset, input.PreviewPreset.String())
 	}
 
 	if input.MaxTranscodeSize != nil {
-		config.Set(config.MaxTranscodeSize, input.MaxTranscodeSize.String())
+		c.Set(config.MaxTranscodeSize, input.MaxTranscodeSize.String())
 	}
 
 	if input.MaxStreamingTranscodeSize != nil {
-		config.Set(config.MaxStreamingTranscodeSize, input.MaxStreamingTranscodeSize.String())
+		c.Set(config.MaxStreamingTranscodeSize, input.MaxStreamingTranscodeSize.String())
 	}
 
 	if input.Username != nil {
-		config.Set(config.Username, input.Username)
+		c.Set(config.Username, input.Username)
 	}
 
 	if input.Password != nil {
 		// bit of a hack - check if the passed in password is the same as the stored hash
 		// and only set if they are different
-		currentPWHash := config.GetPasswordHash()
+		currentPWHash := c.GetPasswordHash()
 
 		if *input.Password != currentPWHash {
-			config.SetPassword(*input.Password)
+			c.SetPassword(*input.Password)
 		}
 	}
 
 	if input.MaxSessionAge != nil {
-		config.Set(config.MaxSessionAge, *input.MaxSessionAge)
+		c.Set(config.MaxSessionAge, *input.MaxSessionAge)
 	}
 
 	if input.LogFile != nil {
-		config.Set(config.LogFile, input.LogFile)
+		c.Set(config.LogFile, input.LogFile)
 	}
 
-	config.Set(config.LogOut, input.LogOut)
-	config.Set(config.LogAccess, input.LogAccess)
+	c.Set(config.LogOut, input.LogOut)
+	c.Set(config.LogAccess, input.LogAccess)
 
-	if input.LogLevel != config.GetLogLevel() {
-		config.Set(config.LogLevel, input.LogLevel)
+	if input.LogLevel != c.GetLogLevel() {
+		c.Set(config.LogLevel, input.LogLevel)
 		logger.SetLogLevel(input.LogLevel)
 	}
 
 	if input.Excludes != nil {
-		config.Set(config.Exclude, input.Excludes)
+		c.Set(config.Exclude, input.Excludes)
 	}
 
 	if input.ImageExcludes != nil {
-		config.Set(config.ImageExclude, input.ImageExcludes)
+		c.Set(config.ImageExclude, input.ImageExcludes)
 	}
 
 	if input.VideoExtensions != nil {
-		config.Set(config.VideoExtensions, input.VideoExtensions)
+		c.Set(config.VideoExtensions, input.VideoExtensions)
 	}
 
 	if input.ImageExtensions != nil {
-		config.Set(config.ImageExtensions, input.ImageExtensions)
+		c.Set(config.ImageExtensions, input.ImageExtensions)
 	}
 
 	if input.GalleryExtensions != nil {
-		config.Set(config.GalleryExtensions, input.GalleryExtensions)
+		c.Set(config.GalleryExtensions, input.GalleryExtensions)
 	}
 
-	config.Set(config.CreateGalleriesFromFolders, input.CreateGalleriesFromFolders)
+	c.Set(config.CreateGalleriesFromFolders, input.CreateGalleriesFromFolders)
+
+	if input.CustomPerformerImageLocation != nil {
+		c.Set(config.CustomPerformerImageLocation, *input.CustomPerformerImageLocation)
+		initialiseCustomImages()
+	}
 
 	refreshScraperCache := false
 	if input.ScraperUserAgent != nil {
-		config.Set(config.ScraperUserAgent, input.ScraperUserAgent)
+		c.Set(config.ScraperUserAgent, input.ScraperUserAgent)
 		refreshScraperCache = true
 	}
 
 	if input.ScraperCDPPath != nil {
-		config.Set(config.ScraperCDPPath, input.ScraperCDPPath)
+		c.Set(config.ScraperCDPPath, input.ScraperCDPPath)
 		refreshScraperCache = true
 	}
 
-	if input.StashBoxes != nil {
-		if err := config.ValidateStashBoxes(input.StashBoxes); err != nil {
-			return nil, err
-		}
-		config.Set(config.StashBoxes, input.StashBoxes)
+	if input.ScraperCertCheck != nil {
+		c.Set(config.ScraperCertCheck, input.ScraperCertCheck)
 	}
 
-	if err := config.Write(); err != nil {
+	if input.StashBoxes != nil {
+		if err := c.ValidateStashBoxes(input.StashBoxes); err != nil {
+			return nil, err
+		}
+		c.Set(config.StashBoxes, input.StashBoxes)
+	}
+
+	if err := c.Write(); err != nil {
 		return makeConfigGeneralResult(), err
 	}
 
@@ -168,32 +207,41 @@ func (r *mutationResolver) ConfigureGeneral(ctx context.Context, input models.Co
 }
 
 func (r *mutationResolver) ConfigureInterface(ctx context.Context, input models.ConfigInterfaceInput) (*models.ConfigInterfaceResult, error) {
+	c := config.GetInstance()
+	if input.MenuItems != nil {
+		c.Set(config.MenuItems, input.MenuItems)
+	}
+
 	if input.SoundOnPreview != nil {
-		config.Set(config.SoundOnPreview, *input.SoundOnPreview)
+		c.Set(config.SoundOnPreview, *input.SoundOnPreview)
 	}
 
 	if input.WallShowTitle != nil {
-		config.Set(config.WallShowTitle, *input.WallShowTitle)
+		c.Set(config.WallShowTitle, *input.WallShowTitle)
 	}
 
 	if input.WallPlayback != nil {
-		config.Set(config.WallPlayback, *input.WallPlayback)
+		c.Set(config.WallPlayback, *input.WallPlayback)
 	}
 
 	if input.MaximumLoopDuration != nil {
-		config.Set(config.MaximumLoopDuration, *input.MaximumLoopDuration)
+		c.Set(config.MaximumLoopDuration, *input.MaximumLoopDuration)
 	}
 
 	if input.AutostartVideo != nil {
-		config.Set(config.AutostartVideo, *input.AutostartVideo)
+		c.Set(config.AutostartVideo, *input.AutostartVideo)
 	}
 
 	if input.ShowStudioAsText != nil {
-		config.Set(config.ShowStudioAsText, *input.ShowStudioAsText)
+		c.Set(config.ShowStudioAsText, *input.ShowStudioAsText)
 	}
 
 	if input.Language != nil {
-		config.Set(config.Language, *input.Language)
+		c.Set(config.Language, *input.Language)
+	}
+
+	if input.SlideshowDelay != nil {
+		c.Set(config.SlideshowDelay, *input.SlideshowDelay)
 	}
 
 	css := ""
@@ -202,15 +250,106 @@ func (r *mutationResolver) ConfigureInterface(ctx context.Context, input models.
 		css = *input.CSS
 	}
 
-	config.SetCSS(css)
+	c.SetCSS(css)
 
 	if input.CSSEnabled != nil {
-		config.Set(config.CSSEnabled, *input.CSSEnabled)
+		c.Set(config.CSSEnabled, *input.CSSEnabled)
 	}
 
-	if err := config.Write(); err != nil {
+	if input.HandyKey != nil {
+		c.Set(config.HandyKey, *input.HandyKey)
+	}
+
+	if input.FunscriptOffset != nil {
+		c.Set(config.FunscriptOffset, *input.FunscriptOffset)
+	}
+
+	if err := c.Write(); err != nil {
 		return makeConfigInterfaceResult(), err
 	}
 
 	return makeConfigInterfaceResult(), nil
 }
+
+func (r *mutationResolver) ConfigureDlna(ctx context.Context, input models.ConfigDLNAInput) (*models.ConfigDLNAResult, error) {
+	c := config.GetInstance()
+
+	if input.ServerName != nil {
+		c.Set(config.DLNAServerName, *input.ServerName)
+	}
+
+	c.Set(config.DLNADefaultIPWhitelist, input.WhitelistedIPs)
+
+	currentDLNAEnabled := c.GetDLNADefaultEnabled()
+	if input.Enabled != nil && *input.Enabled != currentDLNAEnabled {
+		c.Set(config.DLNADefaultEnabled, *input.Enabled)
+
+		// start/stop the DLNA service as needed
+		dlnaService := manager.GetInstance().DLNAService
+		if !*input.Enabled && dlnaService.IsRunning() {
+			dlnaService.Stop(nil)
+		} else if *input.Enabled && !dlnaService.IsRunning() {
+			dlnaService.Start(nil)
+		}
+	}
+
+	c.Set(config.DLNAInterfaces, input.Interfaces)
+
+	if err := c.Write(); err != nil {
+		return makeConfigDLNAResult(), err
+	}
+
+	return makeConfigDLNAResult(), nil
+}
+
+func (r *mutationResolver) ConfigureScraping(ctx context.Context, input models.ConfigScrapingInput) (*models.ConfigScrapingResult, error) {
+	c := config.GetInstance()
+
+	refreshScraperCache := false
+	if input.ScraperUserAgent != nil {
+		c.Set(config.ScraperUserAgent, input.ScraperUserAgent)
+		refreshScraperCache = true
+	}
+
+	if input.ScraperCDPPath != nil {
+		c.Set(config.ScraperCDPPath, input.ScraperCDPPath)
+		refreshScraperCache = true
+	}
+
+	if input.ExcludeTagPatterns != nil {
+		c.Set(config.ScraperExcludeTagPatterns, input.ExcludeTagPatterns)
+	}
+
+	c.Set(config.ScraperCertCheck, input.ScraperCertCheck)
+	if refreshScraperCache {
+		manager.GetInstance().RefreshScraperCache()
+	}
+	if err := c.Write(); err != nil {
+		return makeConfigScrapingResult(), err
+	}
+
+	return makeConfigScrapingResult(), nil
+}
+
+func (r *mutationResolver) GenerateAPIKey(ctx context.Context, input models.GenerateAPIKeyInput) (string, error) {
+	c := config.GetInstance()
+
+	var newAPIKey string
+	if input.Clear == nil || !*input.Clear {
+		username := c.GetUsername()
+		if username != "" {
+			var err error
+			newAPIKey, err = manager.GenerateAPIKey(username)
+			if err != nil {
+				return "", err
+			}
+		}
+	}
+
+	c.Set(config.ApiKey, newAPIKey)
+	if err := c.Write(); err != nil {
+		return newAPIKey, err
+	}
+
+	return newAPIKey, nil
+}

pkg/api/resolver_mutation_dlna.go

@@ -0,0 +1,42 @@
+package api
+
+import (
+	"context"
+	"time"
+
+	"github.com/stashapp/stash/pkg/manager"
+	"github.com/stashapp/stash/pkg/models"
+)
+
+func (r *mutationResolver) EnableDlna(ctx context.Context, input models.EnableDLNAInput) (bool, error) {
+	err := manager.GetInstance().DLNAService.Start(parseMinutes(input.Duration))
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (r *mutationResolver) DisableDlna(ctx context.Context, input models.DisableDLNAInput) (bool, error) {
+	manager.GetInstance().DLNAService.Stop(parseMinutes(input.Duration))
+	return true, nil
+}
+
+func (r *mutationResolver) AddTempDlnaip(ctx context.Context, input models.AddTempDLNAIPInput) (bool, error) {
+	manager.GetInstance().DLNAService.AddTempDLNAIP(input.Address, parseMinutes(input.Duration))
+	return true, nil
+}
+
+func (r *mutationResolver) RemoveTempDlnaip(ctx context.Context, input models.RemoveTempDLNAIPInput) (bool, error) {
+	ret := manager.GetInstance().DLNAService.RemoveTempDLNAIP(input.Address)
+	return ret, nil
+}
+
+func parseMinutes(minutes *int) *time.Duration {
+	var ret *time.Duration
+	if minutes != nil {
+		d := time.Duration(*minutes) * time.Minute
+		ret = &d
+	}
+
+	return ret
+}

pkg/api/resolver_mutation_gallery.go

@@ -4,16 +4,27 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"fmt"
 	"strconv"
 	"time"
 
-	"github.com/jmoiron/sqlx"
-	"github.com/stashapp/stash/pkg/database"
 	"github.com/stashapp/stash/pkg/manager"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/plugin"
 	"github.com/stashapp/stash/pkg/utils"
 )
 
+func (r *mutationResolver) getGallery(ctx context.Context, id int) (ret *models.Gallery, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Gallery().Find(id)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
 func (r *mutationResolver) GalleryCreate(ctx context.Context, input models.GalleryCreateInput) (*models.Gallery, error) {
 	// name must be provided
 	if input.Title == "" {
@@ -61,108 +72,134 @@ func (r *mutationResolver) GalleryCreate(ctx context.Context, input models.Galle
 		newGallery.StudioID = sql.NullInt64{Valid: false}
 	}
 
-	if input.SceneID != nil {
-		sceneID, _ := strconv.ParseInt(*input.SceneID, 10, 64)
-		newGallery.SceneID = sql.NullInt64{Int64: sceneID, Valid: true}
-	} else {
-		// studio must be nullable
-		newGallery.SceneID = sql.NullInt64{Valid: false}
-	}
-
-	// Start the transaction and save the performer
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewGalleryQueryBuilder()
-	jqb := models.NewJoinsQueryBuilder()
-	gallery, err := qb.Create(newGallery, tx)
-	if err != nil {
-		_ = tx.Rollback()
-		return nil, err
-	}
-
-	// Save the performers
-	var performerJoins []models.PerformersGalleries
-	for _, pid := range input.PerformerIds {
-		performerID, _ := strconv.Atoi(pid)
-		performerJoin := models.PerformersGalleries{
-			PerformerID: performerID,
-			GalleryID:   gallery.ID,
-		}
-		performerJoins = append(performerJoins, performerJoin)
-	}
-	if err := jqb.UpdatePerformersGalleries(gallery.ID, performerJoins, tx); err != nil {
-		return nil, err
-	}
-
-	// Save the tags
-	var tagJoins []models.GalleriesTags
-	for _, tid := range input.TagIds {
-		tagID, _ := strconv.Atoi(tid)
-		tagJoin := models.GalleriesTags{
-			GalleryID: gallery.ID,
-			TagID:     tagID,
-		}
-		tagJoins = append(tagJoins, tagJoin)
-	}
-	if err := jqb.UpdateGalleriesTags(gallery.ID, tagJoins, tx); err != nil {
-		return nil, err
-	}
-
-	// Commit
-	if err := tx.Commit(); err != nil {
-		return nil, err
-	}
-
-	return gallery, nil
-}
-
-func (r *mutationResolver) GalleryUpdate(ctx context.Context, input models.GalleryUpdateInput) (*models.Gallery, error) {
 	// Start the transaction and save the gallery
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	ret, err := r.galleryUpdate(input, tx)
-
-	if err != nil {
-		_ = tx.Rollback()
-		return nil, err
-	}
-
-	// Commit
-	if err := tx.Commit(); err != nil {
-		return nil, err
-	}
-
-	return ret, nil
-}
-
-func (r *mutationResolver) GalleriesUpdate(ctx context.Context, input []*models.GalleryUpdateInput) ([]*models.Gallery, error) {
-	// Start the transaction and save the gallery
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	var ret []*models.Gallery
-
-	for _, gallery := range input {
-		thisGallery, err := r.galleryUpdate(*gallery, tx)
-		ret = append(ret, thisGallery)
-
+	var gallery *models.Gallery
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Gallery()
+		var err error
+		gallery, err = qb.Create(newGallery)
+		if err != nil {
+			return err
+		}
+
+		// Save the performers
+		if err := r.updateGalleryPerformers(qb, gallery.ID, input.PerformerIds); err != nil {
+			return err
+		}
+
+		// Save the tags
+		if err := r.updateGalleryTags(qb, gallery.ID, input.TagIds); err != nil {
+			return err
+		}
+
+		// Save the scenes
+		if err := r.updateGalleryScenes(qb, gallery.ID, input.SceneIds); err != nil {
+			return err
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	r.hookExecutor.ExecutePostHooks(ctx, gallery.ID, plugin.GalleryCreatePost, input, nil)
+	return r.getGallery(ctx, gallery.ID)
+}
+
+func (r *mutationResolver) updateGalleryPerformers(qb models.GalleryReaderWriter, galleryID int, performerIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(performerIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdatePerformers(galleryID, ids)
+}
+
+func (r *mutationResolver) updateGalleryTags(qb models.GalleryReaderWriter, galleryID int, tagIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(tagIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdateTags(galleryID, ids)
+}
+
+func (r *mutationResolver) updateGalleryScenes(qb models.GalleryReaderWriter, galleryID int, sceneIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(sceneIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdateScenes(galleryID, ids)
+}
+
+func (r *mutationResolver) GalleryUpdate(ctx context.Context, input models.GalleryUpdateInput) (ret *models.Gallery, err error) {
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
+	}
+
+	// Start the transaction and save the gallery
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		ret, err = r.galleryUpdate(input, translator, repo)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	// execute post hooks outside txn
+	r.hookExecutor.ExecutePostHooks(ctx, ret.ID, plugin.GalleryUpdatePost, input, translator.getFields())
+	return r.getGallery(ctx, ret.ID)
+}
+
+func (r *mutationResolver) GalleriesUpdate(ctx context.Context, input []*models.GalleryUpdateInput) (ret []*models.Gallery, err error) {
+	inputMaps := getUpdateInputMaps(ctx)
+
+	// Start the transaction and save the gallery
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		for i, gallery := range input {
+			translator := changesetTranslator{
+				inputMap: inputMaps[i],
+			}
+
+			thisGallery, err := r.galleryUpdate(*gallery, translator, repo)
+			if err != nil {
+				return err
+			}
+
+			ret = append(ret, thisGallery)
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	// execute post hooks outside txn
+	var newRet []*models.Gallery
+	for i, gallery := range ret {
+		translator := changesetTranslator{
+			inputMap: inputMaps[i],
+		}
+
+		r.hookExecutor.ExecutePostHooks(ctx, gallery.ID, plugin.GalleryUpdatePost, input, translator.getFields())
+		gallery, err = r.getGallery(ctx, gallery.ID)
 		if err != nil {
-			_ = tx.Rollback()
 			return nil, err
 		}
+
+		newRet = append(newRet, gallery)
 	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+	return newRet, nil
+}
+
+func (r *mutationResolver) galleryUpdate(input models.GalleryUpdateInput, translator changesetTranslator, repo models.Repository) (*models.Gallery, error) {
+	qb := repo.Gallery()
+
+	// Populate gallery from the input
+	galleryID, err := strconv.Atoi(input.ID)
+	if err != nil {
 		return nil, err
 	}
 
-	return ret, nil
-}
-
-func (r *mutationResolver) galleryUpdate(input models.GalleryUpdateInput, tx *sqlx.Tx) (*models.Gallery, error) {
-	qb := models.NewGalleryQueryBuilder()
-	// Populate gallery from the input
-	galleryID, _ := strconv.Atoi(input.ID)
-	originalGallery, err := qb.Find(galleryID, nil)
+	originalGallery, err := qb.Find(galleryID)
 	if err != nil {
 		return nil, err
 	}
@@ -176,6 +213,7 @@ func (r *mutationResolver) galleryUpdate(input models.GalleryUpdateInput, tx *sq
 		ID:        galleryID,
 		UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
 	}
+
 	if input.Title != nil {
 		// ensure title is not empty
 		if *input.Title == "" {
@@ -190,65 +228,40 @@ func (r *mutationResolver) galleryUpdate(input models.GalleryUpdateInput, tx *sq
 
 		updatedGallery.Title = &sql.NullString{String: *input.Title, Valid: true}
 	}
-	if input.Details != nil {
-		updatedGallery.Details = &sql.NullString{String: *input.Details, Valid: true}
-	}
-	if input.URL != nil {
-		updatedGallery.URL = &sql.NullString{String: *input.URL, Valid: true}
-	}
-	if input.Date != nil {
-		updatedGallery.Date = &models.SQLiteDate{String: *input.Date, Valid: true}
-	}
 
-	if input.Rating != nil {
-		updatedGallery.Rating = &sql.NullInt64{Int64: int64(*input.Rating), Valid: true}
-	} else {
-		// rating must be nullable
-		updatedGallery.Rating = &sql.NullInt64{Valid: false}
-	}
-
-	if input.StudioID != nil {
-		studioID, _ := strconv.ParseInt(*input.StudioID, 10, 64)
-		updatedGallery.StudioID = &sql.NullInt64{Int64: studioID, Valid: true}
-	} else {
-		// studio must be nullable
-		updatedGallery.StudioID = &sql.NullInt64{Valid: false}
-	}
+	updatedGallery.Details = translator.nullString(input.Details, "details")
+	updatedGallery.URL = translator.nullString(input.URL, "url")
+	updatedGallery.Date = translator.sqliteDate(input.Date, "date")
+	updatedGallery.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedGallery.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
+	updatedGallery.Organized = input.Organized
 
 	// gallery scene is set from the scene only
 
-	jqb := models.NewJoinsQueryBuilder()
-	gallery, err := qb.UpdatePartial(updatedGallery, tx)
+	gallery, err := qb.UpdatePartial(updatedGallery)
 	if err != nil {
 		return nil, err
 	}
 
 	// Save the performers
-	var performerJoins []models.PerformersGalleries
-	for _, pid := range input.PerformerIds {
-		performerID, _ := strconv.Atoi(pid)
-		performerJoin := models.PerformersGalleries{
-			PerformerID: performerID,
-			GalleryID:   galleryID,
+	if translator.hasField("performer_ids") {
+		if err := r.updateGalleryPerformers(qb, galleryID, input.PerformerIds); err != nil {
+			return nil, err
 		}
-		performerJoins = append(performerJoins, performerJoin)
-	}
-	if err := jqb.UpdatePerformersGalleries(galleryID, performerJoins, tx); err != nil {
-		return nil, err
 	}
 
 	// Save the tags
-	var tagJoins []models.GalleriesTags
-	for _, tid := range input.TagIds {
-		tagID, _ := strconv.Atoi(tid)
-		tagJoin := models.GalleriesTags{
-			GalleryID: galleryID,
-			TagID:     tagID,
+	if translator.hasField("tag_ids") {
+		if err := r.updateGalleryTags(qb, galleryID, input.TagIds); err != nil {
+			return nil, err
 		}
-		tagJoins = append(tagJoins, tagJoin)
 	}
-	if err := jqb.UpdateGalleriesTags(galleryID, tagJoins, tx); err != nil {
-		return nil, err
+
+	// Save the scenes
+	if translator.hasField("scene_ids") {
+		if err := r.updateGalleryScenes(qb, galleryID, input.SceneIds); err != nil {
+			return nil, err
+		}
 	}
 
 	return gallery, nil
@@ -258,227 +271,194 @@ func (r *mutationResolver) BulkGalleryUpdate(ctx context.Context, input models.B
 	// Populate gallery from the input
 	updatedTime := time.Now()
 
-	// Start the transaction and save the gallery marker
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewGalleryQueryBuilder()
-	jqb := models.NewJoinsQueryBuilder()
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
+	}
 
 	updatedGallery := models.GalleryPartial{
 		UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
 	}
-	if input.Details != nil {
-		updatedGallery.Details = &sql.NullString{String: *input.Details, Valid: true}
-	}
-	if input.URL != nil {
-		updatedGallery.URL = &sql.NullString{String: *input.URL, Valid: true}
-	}
-	if input.Date != nil {
-		updatedGallery.Date = &models.SQLiteDate{String: *input.Date, Valid: true}
-	}
-	if input.Rating != nil {
-		// a rating of 0 means unset the rating
-		if *input.Rating == 0 {
-			updatedGallery.Rating = &sql.NullInt64{Int64: 0, Valid: false}
-		} else {
-			updatedGallery.Rating = &sql.NullInt64{Int64: int64(*input.Rating), Valid: true}
-		}
-	}
-	if input.StudioID != nil {
-		// empty string means unset the studio
-		if *input.StudioID == "" {
-			updatedGallery.StudioID = &sql.NullInt64{Int64: 0, Valid: false}
-		} else {
-			studioID, _ := strconv.ParseInt(*input.StudioID, 10, 64)
-			updatedGallery.StudioID = &sql.NullInt64{Int64: studioID, Valid: true}
-		}
-	}
-	if input.SceneID != nil {
-		// empty string means unset the studio
-		if *input.SceneID == "" {
-			updatedGallery.SceneID = &sql.NullInt64{Int64: 0, Valid: false}
-		} else {
-			sceneID, _ := strconv.ParseInt(*input.SceneID, 10, 64)
-			updatedGallery.SceneID = &sql.NullInt64{Int64: sceneID, Valid: true}
-		}
-	}
+
+	updatedGallery.Details = translator.nullString(input.Details, "details")
+	updatedGallery.URL = translator.nullString(input.URL, "url")
+	updatedGallery.Date = translator.sqliteDate(input.Date, "date")
+	updatedGallery.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedGallery.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
+	updatedGallery.Organized = input.Organized
 
 	ret := []*models.Gallery{}
 
-	for _, galleryIDStr := range input.Ids {
-		galleryID, _ := strconv.Atoi(galleryIDStr)
-		updatedGallery.ID = galleryID
+	// Start the transaction and save the galleries
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Gallery()
 
-		gallery, err := qb.UpdatePartial(updatedGallery, tx)
-		if err != nil {
-			_ = tx.Rollback()
-			return nil, err
-		}
+		for _, galleryIDStr := range input.Ids {
+			galleryID, _ := strconv.Atoi(galleryIDStr)
+			updatedGallery.ID = galleryID
 
-		ret = append(ret, gallery)
-
-		// Save the performers
-		if wasFieldIncluded(ctx, "performer_ids") {
-			performerIDs, err := adjustGalleryPerformerIDs(tx, galleryID, *input.PerformerIds)
+			gallery, err := qb.UpdatePartial(updatedGallery)
 			if err != nil {
-				_ = tx.Rollback()
-				return nil, err
+				return err
 			}
 
-			var performerJoins []models.PerformersGalleries
-			for _, performerID := range performerIDs {
-				performerJoin := models.PerformersGalleries{
-					PerformerID: performerID,
-					GalleryID:   galleryID,
+			ret = append(ret, gallery)
+
+			// Save the performers
+			if translator.hasField("performer_ids") {
+				performerIDs, err := adjustGalleryPerformerIDs(qb, galleryID, *input.PerformerIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdatePerformers(galleryID, performerIDs); err != nil {
+					return err
 				}
-				performerJoins = append(performerJoins, performerJoin)
 			}
-			if err := jqb.UpdatePerformersGalleries(galleryID, performerJoins, tx); err != nil {
-				_ = tx.Rollback()
-				return nil, err
+
+			// Save the tags
+			if translator.hasField("tag_ids") {
+				tagIDs, err := adjustGalleryTagIDs(qb, galleryID, *input.TagIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdateTags(galleryID, tagIDs); err != nil {
+					return err
+				}
+			}
+
+			// Save the scenes
+			if translator.hasField("scene_ids") {
+				sceneIDs, err := adjustGallerySceneIDs(qb, galleryID, *input.SceneIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdateScenes(galleryID, sceneIDs); err != nil {
+					return err
+				}
 			}
 		}
 
-		// Save the tags
-		if wasFieldIncluded(ctx, "tag_ids") {
-			tagIDs, err := adjustGalleryTagIDs(tx, galleryID, *input.TagIds)
-			if err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-
-			var tagJoins []models.GalleriesTags
-			for _, tagID := range tagIDs {
-				tagJoin := models.GalleriesTags{
-					GalleryID: galleryID,
-					TagID:     tagID,
-				}
-				tagJoins = append(tagJoins, tagJoin)
-			}
-			if err := jqb.UpdateGalleriesTags(galleryID, tagJoins, tx); err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-		}
-	}
-
-	// Commit
-	if err := tx.Commit(); err != nil {
+		return nil
+	}); err != nil {
 		return nil, err
 	}
 
-	return ret, nil
-}
-
-func adjustGalleryPerformerIDs(tx *sqlx.Tx, galleryID int, ids models.BulkUpdateIds) ([]int, error) {
-	var ret []int
-
-	jqb := models.NewJoinsQueryBuilder()
-	if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
-		// adding to the joins
-		performerJoins, err := jqb.GetGalleryPerformers(galleryID, tx)
+	// execute post hooks outside of txn
+	var newRet []*models.Gallery
+	for _, gallery := range ret {
+		r.hookExecutor.ExecutePostHooks(ctx, gallery.ID, plugin.GalleryUpdatePost, input, translator.getFields())
 
+		gallery, err := r.getGallery(ctx, gallery.ID)
 		if err != nil {
 			return nil, err
 		}
 
-		for _, join := range performerJoins {
-			ret = append(ret, join.PerformerID)
-		}
+		newRet = append(newRet, gallery)
+	}
+
+	return newRet, nil
+}
+
+func adjustGalleryPerformerIDs(qb models.GalleryReader, galleryID int, ids models.BulkUpdateIds) (ret []int, err error) {
+	ret, err = qb.GetPerformerIDs(galleryID)
+	if err != nil {
+		return nil, err
 	}
 
 	return adjustIDs(ret, ids), nil
 }
 
-func adjustGalleryTagIDs(tx *sqlx.Tx, galleryID int, ids models.BulkUpdateIds) ([]int, error) {
-	var ret []int
+func adjustGalleryTagIDs(qb models.GalleryReader, galleryID int, ids models.BulkUpdateIds) (ret []int, err error) {
+	ret, err = qb.GetTagIDs(galleryID)
+	if err != nil {
+		return nil, err
+	}
 
-	jqb := models.NewJoinsQueryBuilder()
-	if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
-		// adding to the joins
-		tagJoins, err := jqb.GetGalleryTags(galleryID, tx)
+	return adjustIDs(ret, ids), nil
+}
 
-		if err != nil {
-			return nil, err
-		}
-
-		for _, join := range tagJoins {
-			ret = append(ret, join.TagID)
-		}
+func adjustGallerySceneIDs(qb models.GalleryReader, galleryID int, ids models.BulkUpdateIds) (ret []int, err error) {
+	ret, err = qb.GetSceneIDs(galleryID)
+	if err != nil {
+		return nil, err
 	}
 
 	return adjustIDs(ret, ids), nil
 }
 
 func (r *mutationResolver) GalleryDestroy(ctx context.Context, input models.GalleryDestroyInput) (bool, error) {
-	qb := models.NewGalleryQueryBuilder()
-	iqb := models.NewImageQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
+	galleryIDs, err := utils.StringSliceToIntSlice(input.Ids)
+	if err != nil {
+		return false, err
+	}
 
 	var galleries []*models.Gallery
 	var imgsToPostProcess []*models.Image
 	var imgsToDelete []*models.Image
 
-	for _, id := range input.Ids {
-		galleryID, _ := strconv.Atoi(id)
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Gallery()
+		iqb := repo.Image()
+
+		for _, id := range galleryIDs {
+			gallery, err := qb.Find(id)
+			if err != nil {
+				return err
+			}
+
+			if gallery == nil {
+				return fmt.Errorf("gallery with id %d not found", id)
+			}
 
-		gallery, err := qb.Find(galleryID, tx)
-		if gallery != nil {
 			galleries = append(galleries, gallery)
-		}
-		err = qb.Destroy(galleryID, tx)
 
-		if err != nil {
-			tx.Rollback()
-			return false, err
-		}
-
-		// if this is a zip-based gallery, delete the images as well
-		if gallery.Zip {
-			imgs, err := iqb.FindByGalleryID(galleryID)
-			if err != nil {
-				tx.Rollback()
-				return false, err
-			}
-
-			for _, img := range imgs {
-				err = iqb.Destroy(img.ID, tx)
+			// if this is a zip-based gallery, delete the images as well first
+			if gallery.Zip {
+				imgs, err := iqb.FindByGalleryID(id)
 				if err != nil {
-					tx.Rollback()
-					return false, err
+					return err
 				}
 
-				imgsToPostProcess = append(imgsToPostProcess, img)
-			}
-		} else if input.DeleteFile != nil && *input.DeleteFile {
-			// Delete image if it is only attached to this gallery
-			imgs, err := iqb.FindByGalleryID(galleryID)
-			if err != nil {
-				tx.Rollback()
-				return false, err
-			}
-
-			for _, img := range imgs {
-				imgGalleries, err := qb.FindByImageID(img.ID, tx)
-				if err != nil {
-					tx.Rollback()
-					return false, err
-				}
-
-				if len(imgGalleries) == 0 {
-					err = iqb.Destroy(img.ID, tx)
-					if err != nil {
-						tx.Rollback()
-						return false, err
+				for _, img := range imgs {
+					if err := iqb.Destroy(img.ID); err != nil {
+						return err
 					}
 
-					imgsToDelete = append(imgsToDelete, img)
 					imgsToPostProcess = append(imgsToPostProcess, img)
 				}
+			} else if input.DeleteFile != nil && *input.DeleteFile {
+				// Delete image if it is only attached to this gallery
+				imgs, err := iqb.FindByGalleryID(id)
+				if err != nil {
+					return err
+				}
+
+				for _, img := range imgs {
+					imgGalleries, err := qb.FindByImageID(img.ID)
+					if err != nil {
+						return err
+					}
+
+					if len(imgGalleries) == 0 {
+						if err := iqb.Destroy(img.ID); err != nil {
+							return err
+						}
+
+						imgsToDelete = append(imgsToDelete, img)
+						imgsToPostProcess = append(imgsToPostProcess, img)
+					}
+				}
+			}
+
+			if err := qb.Destroy(id); err != nil {
+				return err
 			}
 		}
-	}
 
-	if err := tx.Commit(); err != nil {
+		return nil
+	}); err != nil {
 		return false, err
 	}
 
@@ -502,38 +482,53 @@ func (r *mutationResolver) GalleryDestroy(ctx context.Context, input models.Gall
 		}
 	}
 
+	// call post hook after performing the other actions
+	for _, gallery := range galleries {
+		r.hookExecutor.ExecutePostHooks(ctx, gallery.ID, plugin.GalleryDestroyPost, input, nil)
+	}
+
+	// call image destroy post hook as well
+	for _, img := range imgsToDelete {
+		r.hookExecutor.ExecutePostHooks(ctx, img.ID, plugin.ImageDestroyPost, nil, nil)
+	}
+
 	return true, nil
 }
 
 func (r *mutationResolver) AddGalleryImages(ctx context.Context, input models.GalleryAddInput) (bool, error) {
-	galleryID, _ := strconv.Atoi(input.GalleryID)
-	qb := models.NewGalleryQueryBuilder()
-	gallery, err := qb.Find(galleryID, nil)
+	galleryID, err := strconv.Atoi(input.GalleryID)
 	if err != nil {
 		return false, err
 	}
 
-	if gallery == nil {
-		return false, errors.New("gallery not found")
+	imageIDs, err := utils.StringSliceToIntSlice(input.ImageIds)
+	if err != nil {
+		return false, err
 	}
 
-	if gallery.Zip {
-		return false, errors.New("cannot modify zip gallery images")
-	}
-
-	jqb := models.NewJoinsQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	for _, id := range input.ImageIds {
-		imageID, _ := strconv.Atoi(id)
-		_, err := jqb.AddImageGallery(imageID, galleryID, tx)
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Gallery()
+		gallery, err := qb.Find(galleryID)
 		if err != nil {
-			tx.Rollback()
-			return false, err
+			return err
 		}
-	}
 
-	if err := tx.Commit(); err != nil {
+		if gallery == nil {
+			return errors.New("gallery not found")
+		}
+
+		if gallery.Zip {
+			return errors.New("cannot modify zip gallery images")
+		}
+
+		newIDs, err := qb.GetImageIDs(galleryID)
+		if err != nil {
+			return err
+		}
+
+		newIDs = utils.IntAppendUniques(newIDs, imageIDs)
+		return qb.UpdateImages(galleryID, newIDs)
+	}); err != nil {
 		return false, err
 	}
 
@@ -541,34 +536,39 @@ func (r *mutationResolver) AddGalleryImages(ctx context.Context, input models.Ga
 }
 
 func (r *mutationResolver) RemoveGalleryImages(ctx context.Context, input models.GalleryRemoveInput) (bool, error) {
-	galleryID, _ := strconv.Atoi(input.GalleryID)
-	qb := models.NewGalleryQueryBuilder()
-	gallery, err := qb.Find(galleryID, nil)
+	galleryID, err := strconv.Atoi(input.GalleryID)
 	if err != nil {
 		return false, err
 	}
 
-	if gallery == nil {
-		return false, errors.New("gallery not found")
+	imageIDs, err := utils.StringSliceToIntSlice(input.ImageIds)
+	if err != nil {
+		return false, err
 	}
 
-	if gallery.Zip {
-		return false, errors.New("cannot modify zip gallery images")
-	}
-
-	jqb := models.NewJoinsQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	for _, id := range input.ImageIds {
-		imageID, _ := strconv.Atoi(id)
-		_, err := jqb.RemoveImageGallery(imageID, galleryID, tx)
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Gallery()
+		gallery, err := qb.Find(galleryID)
 		if err != nil {
-			tx.Rollback()
-			return false, err
+			return err
 		}
-	}
 
-	if err := tx.Commit(); err != nil {
+		if gallery == nil {
+			return errors.New("gallery not found")
+		}
+
+		if gallery.Zip {
+			return errors.New("cannot modify zip gallery images")
+		}
+
+		newIDs, err := qb.GetImageIDs(galleryID)
+		if err != nil {
+			return err
+		}
+
+		newIDs = utils.IntExclude(newIDs, imageIDs)
+		return qb.UpdateImages(galleryID, newIDs)
+	}); err != nil {
 		return false, err
 	}
 

pkg/api/resolver_mutation_image.go

@@ -2,323 +2,300 @@ package api
 
 import (
 	"context"
-	"database/sql"
+	"fmt"
 	"strconv"
 	"time"
 
-	"github.com/jmoiron/sqlx"
-
-	"github.com/stashapp/stash/pkg/database"
 	"github.com/stashapp/stash/pkg/manager"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/plugin"
+	"github.com/stashapp/stash/pkg/utils"
 )
 
-func (r *mutationResolver) ImageUpdate(ctx context.Context, input models.ImageUpdateInput) (*models.Image, error) {
-	// Start the transaction and save the image
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	ret, err := r.imageUpdate(input, tx)
-
-	if err != nil {
-		_ = tx.Rollback()
-		return nil, err
-	}
-
-	// Commit
-	if err := tx.Commit(); err != nil {
+func (r *mutationResolver) getImage(ctx context.Context, id int) (ret *models.Image, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Image().Find(id)
+		return err
+	}); err != nil {
 		return nil, err
 	}
 
 	return ret, nil
 }
 
-func (r *mutationResolver) ImagesUpdate(ctx context.Context, input []*models.ImageUpdateInput) ([]*models.Image, error) {
+func (r *mutationResolver) ImageUpdate(ctx context.Context, input models.ImageUpdateInput) (ret *models.Image, err error) {
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
+	}
+
 	// Start the transaction and save the image
-	tx := database.DB.MustBeginTx(ctx, nil)
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		ret, err = r.imageUpdate(input, translator, repo)
+		return err
+	}); err != nil {
+		return nil, err
+	}
 
-	var ret []*models.Image
+	// execute post hooks outside txn
+	r.hookExecutor.ExecutePostHooks(ctx, ret.ID, plugin.ImageUpdatePost, input, translator.getFields())
+	return r.getImage(ctx, ret.ID)
+}
 
-	for _, image := range input {
-		thisImage, err := r.imageUpdate(*image, tx)
-		ret = append(ret, thisImage)
+func (r *mutationResolver) ImagesUpdate(ctx context.Context, input []*models.ImageUpdateInput) (ret []*models.Image, err error) {
+	inputMaps := getUpdateInputMaps(ctx)
 
+	// Start the transaction and save the image
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		for i, image := range input {
+			translator := changesetTranslator{
+				inputMap: inputMaps[i],
+			}
+
+			thisImage, err := r.imageUpdate(*image, translator, repo)
+			if err != nil {
+				return err
+			}
+
+			ret = append(ret, thisImage)
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	// execute post hooks outside txn
+	var newRet []*models.Image
+	for i, image := range ret {
+		translator := changesetTranslator{
+			inputMap: inputMaps[i],
+		}
+
+		r.hookExecutor.ExecutePostHooks(ctx, image.ID, plugin.ImageUpdatePost, input, translator.getFields())
+		image, err = r.getImage(ctx, image.ID)
 		if err != nil {
-			_ = tx.Rollback()
 			return nil, err
 		}
+
+		newRet = append(newRet, image)
 	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
-		return nil, err
-	}
-
-	return ret, nil
+	return newRet, nil
 }
 
-func (r *mutationResolver) imageUpdate(input models.ImageUpdateInput, tx *sqlx.Tx) (*models.Image, error) {
+func (r *mutationResolver) imageUpdate(input models.ImageUpdateInput, translator changesetTranslator, repo models.Repository) (*models.Image, error) {
 	// Populate image from the input
-	imageID, _ := strconv.Atoi(input.ID)
+	imageID, err := strconv.Atoi(input.ID)
+	if err != nil {
+		return nil, err
+	}
 
 	updatedTime := time.Now()
 	updatedImage := models.ImagePartial{
 		ID:        imageID,
 		UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
 	}
-	if input.Title != nil {
-		updatedImage.Title = &sql.NullString{String: *input.Title, Valid: true}
-	}
 
-	if input.Rating != nil {
-		updatedImage.Rating = &sql.NullInt64{Int64: int64(*input.Rating), Valid: true}
-	} else {
-		// rating must be nullable
-		updatedImage.Rating = &sql.NullInt64{Valid: false}
-	}
+	updatedImage.Title = translator.nullString(input.Title, "title")
+	updatedImage.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedImage.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
+	updatedImage.Organized = input.Organized
 
-	if input.StudioID != nil {
-		studioID, _ := strconv.ParseInt(*input.StudioID, 10, 64)
-		updatedImage.StudioID = &sql.NullInt64{Int64: studioID, Valid: true}
-	} else {
-		// studio must be nullable
-		updatedImage.StudioID = &sql.NullInt64{Valid: false}
-	}
-
-	qb := models.NewImageQueryBuilder()
-	jqb := models.NewJoinsQueryBuilder()
-	image, err := qb.Update(updatedImage, tx)
+	qb := repo.Image()
+	image, err := qb.Update(updatedImage)
 	if err != nil {
 		return nil, err
 	}
 
-	// don't set the galleries directly. Use add/remove gallery images interface instead
+	if translator.hasField("gallery_ids") {
+		if err := r.updateImageGalleries(qb, imageID, input.GalleryIds); err != nil {
+			return nil, err
+		}
+	}
 
 	// Save the performers
-	var performerJoins []models.PerformersImages
-	for _, pid := range input.PerformerIds {
-		performerID, _ := strconv.Atoi(pid)
-		performerJoin := models.PerformersImages{
-			PerformerID: performerID,
-			ImageID:     imageID,
+	if translator.hasField("performer_ids") {
+		if err := r.updateImagePerformers(qb, imageID, input.PerformerIds); err != nil {
+			return nil, err
 		}
-		performerJoins = append(performerJoins, performerJoin)
-	}
-	if err := jqb.UpdatePerformersImages(imageID, performerJoins, tx); err != nil {
-		return nil, err
 	}
 
 	// Save the tags
-	var tagJoins []models.ImagesTags
-	for _, tid := range input.TagIds {
-		tagID, _ := strconv.Atoi(tid)
-		tagJoin := models.ImagesTags{
-			ImageID: imageID,
-			TagID:   tagID,
+	if translator.hasField("tag_ids") {
+		if err := r.updateImageTags(qb, imageID, input.TagIds); err != nil {
+			return nil, err
 		}
-		tagJoins = append(tagJoins, tagJoin)
-	}
-	if err := jqb.UpdateImagesTags(imageID, tagJoins, tx); err != nil {
-		return nil, err
 	}
 
 	return image, nil
 }
 
-func (r *mutationResolver) BulkImageUpdate(ctx context.Context, input models.BulkImageUpdateInput) ([]*models.Image, error) {
+func (r *mutationResolver) updateImageGalleries(qb models.ImageReaderWriter, imageID int, galleryIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(galleryIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdateGalleries(imageID, ids)
+}
+
+func (r *mutationResolver) updateImagePerformers(qb models.ImageReaderWriter, imageID int, performerIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(performerIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdatePerformers(imageID, ids)
+}
+
+func (r *mutationResolver) updateImageTags(qb models.ImageReaderWriter, imageID int, tagsIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(tagsIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdateTags(imageID, ids)
+}
+
+func (r *mutationResolver) BulkImageUpdate(ctx context.Context, input models.BulkImageUpdateInput) (ret []*models.Image, err error) {
+	imageIDs, err := utils.StringSliceToIntSlice(input.Ids)
+	if err != nil {
+		return nil, err
+	}
+
 	// Populate image from the input
 	updatedTime := time.Now()
 
-	// Start the transaction and save the image marker
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewImageQueryBuilder()
-	jqb := models.NewJoinsQueryBuilder()
-
 	updatedImage := models.ImagePartial{
 		UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
 	}
-	if input.Title != nil {
-		updatedImage.Title = &sql.NullString{String: *input.Title, Valid: true}
-	}
-	if input.Rating != nil {
-		// a rating of 0 means unset the rating
-		if *input.Rating == 0 {
-			updatedImage.Rating = &sql.NullInt64{Int64: 0, Valid: false}
-		} else {
-			updatedImage.Rating = &sql.NullInt64{Int64: int64(*input.Rating), Valid: true}
-		}
-	}
-	if input.StudioID != nil {
-		// empty string means unset the studio
-		if *input.StudioID == "" {
-			updatedImage.StudioID = &sql.NullInt64{Int64: 0, Valid: false}
-		} else {
-			studioID, _ := strconv.ParseInt(*input.StudioID, 10, 64)
-			updatedImage.StudioID = &sql.NullInt64{Int64: studioID, Valid: true}
-		}
+
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
 	}
 
-	ret := []*models.Image{}
+	updatedImage.Title = translator.nullString(input.Title, "title")
+	updatedImage.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedImage.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
+	updatedImage.Organized = input.Organized
 
-	for _, imageIDStr := range input.Ids {
-		imageID, _ := strconv.Atoi(imageIDStr)
-		updatedImage.ID = imageID
+	// Start the transaction and save the image marker
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Image()
 
-		image, err := qb.Update(updatedImage, tx)
-		if err != nil {
-			_ = tx.Rollback()
-			return nil, err
-		}
+		for _, imageID := range imageIDs {
+			updatedImage.ID = imageID
 
-		ret = append(ret, image)
-
-		// Save the galleries
-		if wasFieldIncluded(ctx, "gallery_ids") {
-			galleryIDs, err := adjustImageGalleryIDs(tx, imageID, *input.GalleryIds)
+			image, err := qb.Update(updatedImage)
 			if err != nil {
-				_ = tx.Rollback()
-				return nil, err
+				return err
 			}
 
-			var galleryJoins []models.GalleriesImages
-			for _, gid := range galleryIDs {
-				galleryJoin := models.GalleriesImages{
-					GalleryID: gid,
-					ImageID:   imageID,
+			ret = append(ret, image)
+
+			// Save the galleries
+			if translator.hasField("gallery_ids") {
+				galleryIDs, err := adjustImageGalleryIDs(qb, imageID, *input.GalleryIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdateGalleries(imageID, galleryIDs); err != nil {
+					return err
 				}
-				galleryJoins = append(galleryJoins, galleryJoin)
 			}
-			if err := jqb.UpdateGalleriesImages(imageID, galleryJoins, tx); err != nil {
-				return nil, err
+
+			// Save the performers
+			if translator.hasField("performer_ids") {
+				performerIDs, err := adjustImagePerformerIDs(qb, imageID, *input.PerformerIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdatePerformers(imageID, performerIDs); err != nil {
+					return err
+				}
+			}
+
+			// Save the tags
+			if translator.hasField("tag_ids") {
+				tagIDs, err := adjustImageTagIDs(qb, imageID, *input.TagIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdateTags(imageID, tagIDs); err != nil {
+					return err
+				}
 			}
 		}
 
-		// Save the performers
-		if wasFieldIncluded(ctx, "performer_ids") {
-			performerIDs, err := adjustImagePerformerIDs(tx, imageID, *input.PerformerIds)
-			if err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-
-			var performerJoins []models.PerformersImages
-			for _, performerID := range performerIDs {
-				performerJoin := models.PerformersImages{
-					PerformerID: performerID,
-					ImageID:     imageID,
-				}
-				performerJoins = append(performerJoins, performerJoin)
-			}
-			if err := jqb.UpdatePerformersImages(imageID, performerJoins, tx); err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-		}
-
-		// Save the tags
-		if wasFieldIncluded(ctx, "tag_ids") {
-			tagIDs, err := adjustImageTagIDs(tx, imageID, *input.TagIds)
-			if err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-
-			var tagJoins []models.ImagesTags
-			for _, tagID := range tagIDs {
-				tagJoin := models.ImagesTags{
-					ImageID: imageID,
-					TagID:   tagID,
-				}
-				tagJoins = append(tagJoins, tagJoin)
-			}
-			if err := jqb.UpdateImagesTags(imageID, tagJoins, tx); err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-		}
-	}
-
-	// Commit
-	if err := tx.Commit(); err != nil {
+		return nil
+	}); err != nil {
 		return nil, err
 	}
 
-	return ret, nil
-}
-
-func adjustImageGalleryIDs(tx *sqlx.Tx, imageID int, ids models.BulkUpdateIds) ([]int, error) {
-	var ret []int
-
-	jqb := models.NewJoinsQueryBuilder()
-	if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
-		// adding to the joins
-		galleryJoins, err := jqb.GetImageGalleries(imageID, tx)
+	// execute post hooks outside of txn
+	var newRet []*models.Image
+	for _, image := range ret {
+		r.hookExecutor.ExecutePostHooks(ctx, image.ID, plugin.ImageUpdatePost, input, translator.getFields())
 
+		image, err = r.getImage(ctx, image.ID)
 		if err != nil {
 			return nil, err
 		}
 
-		for _, join := range galleryJoins {
-			ret = append(ret, join.GalleryID)
-		}
+		newRet = append(newRet, image)
 	}
 
-	return adjustIDs(ret, ids), nil
+	return newRet, nil
 }
 
-func adjustImagePerformerIDs(tx *sqlx.Tx, imageID int, ids models.BulkUpdateIds) ([]int, error) {
-	var ret []int
-
-	jqb := models.NewJoinsQueryBuilder()
-	if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
-		// adding to the joins
-		performerJoins, err := jqb.GetImagePerformers(imageID, tx)
-
-		if err != nil {
-			return nil, err
-		}
-
-		for _, join := range performerJoins {
-			ret = append(ret, join.PerformerID)
-		}
-	}
-
-	return adjustIDs(ret, ids), nil
-}
-
-func adjustImageTagIDs(tx *sqlx.Tx, imageID int, ids models.BulkUpdateIds) ([]int, error) {
-	var ret []int
-
-	jqb := models.NewJoinsQueryBuilder()
-	if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
-		// adding to the joins
-		tagJoins, err := jqb.GetImageTags(imageID, tx)
-
-		if err != nil {
-			return nil, err
-		}
-
-		for _, join := range tagJoins {
-			ret = append(ret, join.TagID)
-		}
-	}
-
-	return adjustIDs(ret, ids), nil
-}
-
-func (r *mutationResolver) ImageDestroy(ctx context.Context, input models.ImageDestroyInput) (bool, error) {
-	qb := models.NewImageQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	imageID, _ := strconv.Atoi(input.ID)
-	image, err := qb.Find(imageID)
-	err = qb.Destroy(imageID, tx)
-
+func adjustImageGalleryIDs(qb models.ImageReader, imageID int, ids models.BulkUpdateIds) (ret []int, err error) {
+	ret, err = qb.GetGalleryIDs(imageID)
+	if err != nil {
+		return nil, err
+	}
+
+	return adjustIDs(ret, ids), nil
+}
+
+func adjustImagePerformerIDs(qb models.ImageReader, imageID int, ids models.BulkUpdateIds) (ret []int, err error) {
+	ret, err = qb.GetPerformerIDs(imageID)
+	if err != nil {
+		return nil, err
+	}
+
+	return adjustIDs(ret, ids), nil
+}
+
+func adjustImageTagIDs(qb models.ImageReader, imageID int, ids models.BulkUpdateIds) (ret []int, err error) {
+	ret, err = qb.GetTagIDs(imageID)
+	if err != nil {
+		return nil, err
+	}
+
+	return adjustIDs(ret, ids), nil
+}
+
+func (r *mutationResolver) ImageDestroy(ctx context.Context, input models.ImageDestroyInput) (ret bool, err error) {
+	imageID, err := strconv.Atoi(input.ID)
 	if err != nil {
-		tx.Rollback()
 		return false, err
 	}
 
-	if err := tx.Commit(); err != nil {
+	var image *models.Image
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Image()
+
+		image, err = qb.Find(imageID)
+		if err != nil {
+			return err
+		}
+
+		if image == nil {
+			return fmt.Errorf("image with id %d not found", imageID)
+		}
+
+		return qb.Destroy(imageID)
+	}); err != nil {
 		return false, err
 	}
 
@@ -334,30 +311,41 @@ func (r *mutationResolver) ImageDestroy(ctx context.Context, input models.ImageD
 		manager.DeleteImageFile(image)
 	}
 
+	// call post hook after performing the other actions
+	r.hookExecutor.ExecutePostHooks(ctx, image.ID, plugin.ImageDestroyPost, input, nil)
+
 	return true, nil
 }
 
-func (r *mutationResolver) ImagesDestroy(ctx context.Context, input models.ImagesDestroyInput) (bool, error) {
-	qb := models.NewImageQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
-
-	var images []*models.Image
-	for _, id := range input.Ids {
-		imageID, _ := strconv.Atoi(id)
-
-		image, err := qb.Find(imageID)
-		if image != nil {
-			images = append(images, image)
-		}
-		err = qb.Destroy(imageID, tx)
-
-		if err != nil {
-			tx.Rollback()
-			return false, err
-		}
+func (r *mutationResolver) ImagesDestroy(ctx context.Context, input models.ImagesDestroyInput) (ret bool, err error) {
+	imageIDs, err := utils.StringSliceToIntSlice(input.Ids)
+	if err != nil {
+		return false, err
 	}
 
-	if err := tx.Commit(); err != nil {
+	var images []*models.Image
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Image()
+
+		for _, imageID := range imageIDs {
+
+			image, err := qb.Find(imageID)
+			if err != nil {
+				return err
+			}
+
+			if image == nil {
+				return fmt.Errorf("image with id %d not found", imageID)
+			}
+
+			images = append(images, image)
+			if err := qb.Destroy(imageID); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
 		return false, err
 	}
 
@@ -373,67 +361,64 @@ func (r *mutationResolver) ImagesDestroy(ctx context.Context, input models.Image
 		if input.DeleteFile != nil && *input.DeleteFile {
 			manager.DeleteImageFile(image)
 		}
+
+		// call post hook after performing the other actions
+		r.hookExecutor.ExecutePostHooks(ctx, image.ID, plugin.ImageDestroyPost, input, nil)
 	}
 
 	return true, nil
 }
 
-func (r *mutationResolver) ImageIncrementO(ctx context.Context, id string) (int, error) {
-	imageID, _ := strconv.Atoi(id)
-
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewImageQueryBuilder()
-
-	newVal, err := qb.IncrementOCounter(imageID, tx)
+func (r *mutationResolver) ImageIncrementO(ctx context.Context, id string) (ret int, err error) {
+	imageID, err := strconv.Atoi(id)
 	if err != nil {
-		_ = tx.Rollback()
 		return 0, err
 	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Image()
+
+		ret, err = qb.IncrementOCounter(imageID)
+		return err
+	}); err != nil {
 		return 0, err
 	}
 
-	return newVal, nil
+	return ret, nil
 }
 
-func (r *mutationResolver) ImageDecrementO(ctx context.Context, id string) (int, error) {
-	imageID, _ := strconv.Atoi(id)
-
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewImageQueryBuilder()
-
-	newVal, err := qb.DecrementOCounter(imageID, tx)
+func (r *mutationResolver) ImageDecrementO(ctx context.Context, id string) (ret int, err error) {
+	imageID, err := strconv.Atoi(id)
 	if err != nil {
-		_ = tx.Rollback()
 		return 0, err
 	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Image()
+
+		ret, err = qb.DecrementOCounter(imageID)
+		return err
+	}); err != nil {
 		return 0, err
 	}
 
-	return newVal, nil
+	return ret, nil
 }
 
-func (r *mutationResolver) ImageResetO(ctx context.Context, id string) (int, error) {
-	imageID, _ := strconv.Atoi(id)
-
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewImageQueryBuilder()
-
-	newVal, err := qb.ResetOCounter(imageID, tx)
+func (r *mutationResolver) ImageResetO(ctx context.Context, id string) (ret int, err error) {
+	imageID, err := strconv.Atoi(id)
 	if err != nil {
-		_ = tx.Rollback()
 		return 0, err
 	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Image()
+
+		ret, err = qb.ResetOCounter(imageID)
+		return err
+	}); err != nil {
 		return 0, err
 	}
 
-	return newVal, nil
+	return ret, nil
 }

pkg/api/resolver_mutation_job.go

@@ -0,0 +1,23 @@
+package api
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/stashapp/stash/pkg/manager"
+)
+
+func (r *mutationResolver) StopJob(ctx context.Context, jobID string) (bool, error) {
+	idInt, err := strconv.Atoi(jobID)
+	if err != nil {
+		return false, err
+	}
+	manager.GetInstance().JobManager.CancelJob(idInt)
+
+	return true, nil
+}
+
+func (r *mutationResolver) StopAllJobs(ctx context.Context) (bool, error) {
+	manager.GetInstance().JobManager.CancelAll()
+	return true, nil
+}

pkg/api/resolver_mutation_metadata.go

@@ -2,46 +2,65 @@ package api
 
 import (
 	"context"
+	"io/ioutil"
+	"path/filepath"
+	"strconv"
+	"sync"
 	"time"
 
+	"github.com/stashapp/stash/pkg/database"
+	"github.com/stashapp/stash/pkg/logger"
 	"github.com/stashapp/stash/pkg/manager"
 	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/utils"
 )
 
 func (r *mutationResolver) MetadataScan(ctx context.Context, input models.ScanMetadataInput) (string, error) {
-	manager.GetInstance().Scan(input)
-	return "todo", nil
-}
+	jobID, err := manager.GetInstance().Scan(ctx, input)
 
-func (r *mutationResolver) MetadataImport(ctx context.Context) (string, error) {
-	manager.GetInstance().Import()
-	return "todo", nil
-}
-
-func (r *mutationResolver) ImportObjects(ctx context.Context, input models.ImportObjectsInput) (string, error) {
-	t := manager.CreateImportTask(config.GetVideoFileNamingAlgorithm(), input)
-	_, err := manager.GetInstance().RunSingleTask(t)
 	if err != nil {
 		return "", err
 	}
 
-	return "todo", nil
+	return strconv.Itoa(jobID), nil
+}
+
+func (r *mutationResolver) MetadataImport(ctx context.Context) (string, error) {
+	jobID, err := manager.GetInstance().Import(ctx)
+	if err != nil {
+		return "", err
+	}
+
+	return strconv.Itoa(jobID), nil
+}
+
+func (r *mutationResolver) ImportObjects(ctx context.Context, input models.ImportObjectsInput) (string, error) {
+	t, err := manager.CreateImportTask(config.GetInstance().GetVideoFileNamingAlgorithm(), input)
+	if err != nil {
+		return "", err
+	}
+
+	jobID := manager.GetInstance().RunSingleTask(ctx, t)
+
+	return strconv.Itoa(jobID), nil
 }
 
 func (r *mutationResolver) MetadataExport(ctx context.Context) (string, error) {
-	manager.GetInstance().Export()
-	return "todo", nil
+	jobID, err := manager.GetInstance().Export(ctx)
+	if err != nil {
+		return "", err
+	}
+
+	return strconv.Itoa(jobID), nil
 }
 
 func (r *mutationResolver) ExportObjects(ctx context.Context, input models.ExportObjectsInput) (*string, error) {
-	t := manager.CreateExportTask(config.GetVideoFileNamingAlgorithm(), input)
-	wg, err := manager.GetInstance().RunSingleTask(t)
-	if err != nil {
-		return nil, err
-	}
+	t := manager.CreateExportTask(config.GetInstance().GetVideoFileNamingAlgorithm(), input)
 
-	wg.Wait()
+	var wg sync.WaitGroup
+	wg.Add(1)
+	t.Start(&wg)
 
 	if t.DownloadHash != "" {
 		baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
@@ -56,36 +75,65 @@ func (r *mutationResolver) ExportObjects(ctx context.Context, input models.Expor
 }
 
 func (r *mutationResolver) MetadataGenerate(ctx context.Context, input models.GenerateMetadataInput) (string, error) {
-	manager.GetInstance().Generate(input)
-	return "todo", nil
+	jobID, err := manager.GetInstance().Generate(ctx, input)
+
+	if err != nil {
+		return "", err
+	}
+
+	return strconv.Itoa(jobID), nil
 }
 
 func (r *mutationResolver) MetadataAutoTag(ctx context.Context, input models.AutoTagMetadataInput) (string, error) {
-	manager.GetInstance().AutoTag(input.Performers, input.Studios, input.Tags)
-	return "todo", nil
+	jobID := manager.GetInstance().AutoTag(ctx, input)
+	return strconv.Itoa(jobID), nil
 }
 
-func (r *mutationResolver) MetadataClean(ctx context.Context) (string, error) {
-	manager.GetInstance().Clean()
-	return "todo", nil
+func (r *mutationResolver) MetadataClean(ctx context.Context, input models.CleanMetadataInput) (string, error) {
+	jobID := manager.GetInstance().Clean(ctx, input)
+	return strconv.Itoa(jobID), nil
 }
 
 func (r *mutationResolver) MigrateHashNaming(ctx context.Context) (string, error) {
-	manager.GetInstance().MigrateHash()
-	return "todo", nil
+	jobID := manager.GetInstance().MigrateHash(ctx)
+	return strconv.Itoa(jobID), nil
 }
 
-func (r *mutationResolver) JobStatus(ctx context.Context) (*models.MetadataUpdateStatus, error) {
-	status := manager.GetInstance().Status
-	ret := models.MetadataUpdateStatus{
-		Progress: status.Progress,
-		Status:   status.Status.String(),
-		Message:  "",
+func (r *mutationResolver) BackupDatabase(ctx context.Context, input models.BackupDatabaseInput) (*string, error) {
+	// if download is true, then backup to temporary file and return a link
+	download := input.Download != nil && *input.Download
+	mgr := manager.GetInstance()
+	var backupPath string
+	if download {
+		utils.EnsureDir(mgr.Paths.Generated.Downloads)
+		f, err := ioutil.TempFile(mgr.Paths.Generated.Downloads, "backup*.sqlite")
+		if err != nil {
+			return nil, err
+		}
+
+		backupPath = f.Name()
+		f.Close()
+	} else {
+		backupPath = database.DatabaseBackupPath()
 	}
 
-	return &ret, nil
-}
+	err := database.Backup(database.DB, backupPath)
+	if err != nil {
+		return nil, err
+	}
 
-func (r *mutationResolver) StopJob(ctx context.Context) (bool, error) {
-	return manager.GetInstance().Status.Stop(), nil
+	if download {
+		downloadHash := mgr.DownloadStore.RegisterFile(backupPath, "", false)
+		logger.Debugf("Generated backup file %s with hash %s", backupPath, downloadHash)
+
+		baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
+
+		fn := filepath.Base(database.DatabaseBackupPath())
+		ret := baseURL + "/downloads/" + downloadHash + "/" + fn
+		return &ret, nil
+	} else {
+		logger.Infof("Successfully backed up database to: %s", backupPath)
+	}
+
+	return nil, nil
 }

pkg/api/resolver_mutation_movie.go

@@ -6,11 +6,22 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/stashapp/stash/pkg/database"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/plugin"
 	"github.com/stashapp/stash/pkg/utils"
 )
 
+func (r *mutationResolver) getMovie(ctx context.Context, id int) (ret *models.Movie, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Movie().Find(id)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
 func (r *mutationResolver) MovieCreate(ctx context.Context, input models.MovieCreateInput) (*models.Movie, error) {
 	// generate checksum from movie name rather than image
 	checksum := utils.MD5FromString(input.Name)
@@ -27,7 +38,7 @@ func (r *mutationResolver) MovieCreate(ctx context.Context, input models.MovieCr
 
 	// Process the base 64 encoded image string
 	if input.FrontImage != nil {
-		_, frontimageData, err = utils.ProcessBase64Image(*input.FrontImage)
+		frontimageData, err = utils.ProcessImageInput(*input.FrontImage)
 		if err != nil {
 			return nil, err
 		}
@@ -35,7 +46,7 @@ func (r *mutationResolver) MovieCreate(ctx context.Context, input models.MovieCr
 
 	// Process the base 64 encoded image string
 	if input.BackImage != nil {
-		_, backimageData, err = utils.ProcessBase64Image(*input.BackImage)
+		backimageData, err = utils.ProcessImageInput(*input.BackImage)
 		if err != nil {
 			return nil, err
 		}
@@ -85,51 +96,58 @@ func (r *mutationResolver) MovieCreate(ctx context.Context, input models.MovieCr
 	}
 
 	// Start the transaction and save the movie
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewMovieQueryBuilder()
-	movie, err := qb.Create(newMovie, tx)
-	if err != nil {
-		_ = tx.Rollback()
-		return nil, err
-	}
-
-	// update image table
-	if len(frontimageData) > 0 {
-		if err := qb.UpdateMovieImages(movie.ID, frontimageData, backimageData, tx); err != nil {
-			_ = tx.Rollback()
-			return nil, err
+	var movie *models.Movie
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Movie()
+		movie, err = qb.Create(newMovie)
+		if err != nil {
+			return err
 		}
-	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+		// update image table
+		if len(frontimageData) > 0 {
+			if err := qb.UpdateImages(movie.ID, frontimageData, backimageData); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
 		return nil, err
 	}
 
-	return movie, nil
+	r.hookExecutor.ExecutePostHooks(ctx, movie.ID, plugin.MovieCreatePost, input, nil)
+	return r.getMovie(ctx, movie.ID)
 }
 
 func (r *mutationResolver) MovieUpdate(ctx context.Context, input models.MovieUpdateInput) (*models.Movie, error) {
 	// Populate movie from the input
-	movieID, _ := strconv.Atoi(input.ID)
+	movieID, err := strconv.Atoi(input.ID)
+	if err != nil {
+		return nil, err
+	}
 
 	updatedMovie := models.MoviePartial{
 		ID:        movieID,
 		UpdatedAt: &models.SQLiteTimestamp{Timestamp: time.Now()},
 	}
+
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
+	}
+
 	var frontimageData []byte
-	var err error
-	frontImageIncluded := wasFieldIncluded(ctx, "front_image")
+	frontImageIncluded := translator.hasField("front_image")
 	if input.FrontImage != nil {
-		_, frontimageData, err = utils.ProcessBase64Image(*input.FrontImage)
+		frontimageData, err = utils.ProcessImageInput(*input.FrontImage)
 		if err != nil {
 			return nil, err
 		}
 	}
-	backImageIncluded := wasFieldIncluded(ctx, "back_image")
+	backImageIncluded := translator.hasField("back_image")
 	var backimageData []byte
 	if input.BackImage != nil {
-		_, backimageData, err = utils.ProcessBase64Image(*input.BackImage)
+		backimageData, err = utils.ProcessImageInput(*input.BackImage)
 		if err != nil {
 			return nil, err
 		}
@@ -142,109 +160,105 @@ func (r *mutationResolver) MovieUpdate(ctx context.Context, input models.MovieUp
 		updatedMovie.Checksum = &checksum
 	}
 
-	if input.Aliases != nil {
-		updatedMovie.Aliases = &sql.NullString{String: *input.Aliases, Valid: true}
-	}
-	if input.Duration != nil {
-		duration := int64(*input.Duration)
-		updatedMovie.Duration = &sql.NullInt64{Int64: duration, Valid: true}
-	}
-
-	if input.Date != nil {
-		updatedMovie.Date = &models.SQLiteDate{String: *input.Date, Valid: true}
-	}
-
-	if input.Rating != nil {
-		rating := int64(*input.Rating)
-		updatedMovie.Rating = &sql.NullInt64{Int64: rating, Valid: true}
-	} else {
-		// rating must be nullable
-		updatedMovie.Rating = &sql.NullInt64{Valid: false}
-	}
-
-	if input.StudioID != nil {
-		studioID, _ := strconv.ParseInt(*input.StudioID, 10, 64)
-		updatedMovie.StudioID = &sql.NullInt64{Int64: studioID, Valid: true}
-	} else {
-		// studio must be nullable
-		updatedMovie.StudioID = &sql.NullInt64{Valid: false}
-	}
-
-	if input.Director != nil {
-		updatedMovie.Director = &sql.NullString{String: *input.Director, Valid: true}
-	}
-
-	if input.Synopsis != nil {
-		updatedMovie.Synopsis = &sql.NullString{String: *input.Synopsis, Valid: true}
-	}
-
-	if input.URL != nil {
-		updatedMovie.URL = &sql.NullString{String: *input.URL, Valid: true}
-	}
+	updatedMovie.Aliases = translator.nullString(input.Aliases, "aliases")
+	updatedMovie.Duration = translator.nullInt64(input.Duration, "duration")
+	updatedMovie.Date = translator.sqliteDate(input.Date, "date")
+	updatedMovie.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedMovie.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
+	updatedMovie.Director = translator.nullString(input.Director, "director")
+	updatedMovie.Synopsis = translator.nullString(input.Synopsis, "synopsis")
+	updatedMovie.URL = translator.nullString(input.URL, "url")
 
 	// Start the transaction and save the movie
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewMovieQueryBuilder()
-	movie, err := qb.Update(updatedMovie, tx)
-	if err != nil {
-		_ = tx.Rollback()
+	var movie *models.Movie
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Movie()
+		movie, err = qb.Update(updatedMovie)
+		if err != nil {
+			return err
+		}
+
+		// update image table
+		if frontImageIncluded || backImageIncluded {
+			if !frontImageIncluded {
+				frontimageData, err = qb.GetFrontImage(updatedMovie.ID)
+				if err != nil {
+					return err
+				}
+			}
+			if !backImageIncluded {
+				backimageData, err = qb.GetBackImage(updatedMovie.ID)
+				if err != nil {
+					return err
+				}
+			}
+
+			if len(frontimageData) == 0 && len(backimageData) == 0 {
+				// both images are being nulled. Destroy them.
+				if err := qb.DestroyImages(movie.ID); err != nil {
+					return err
+				}
+			} else {
+				// HACK - if front image is null and back image is not null, then set the front image
+				// to the default image since we can't have a null front image and a non-null back image
+				if frontimageData == nil && backimageData != nil {
+					frontimageData, _ = utils.ProcessImageInput(models.DefaultMovieImage)
+				}
+
+				if err := qb.UpdateImages(movie.ID, frontimageData, backimageData); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	}); err != nil {
 		return nil, err
 	}
 
-	// update image table
-	if frontImageIncluded || backImageIncluded {
-		if !frontImageIncluded {
-			frontimageData, err = qb.GetFrontImage(updatedMovie.ID, tx)
-			if err != nil {
-				tx.Rollback()
-				return nil, err
-			}
-		}
-		if !backImageIncluded {
-			backimageData, err = qb.GetBackImage(updatedMovie.ID, tx)
-			if err != nil {
-				tx.Rollback()
-				return nil, err
-			}
-		}
-
-		if len(frontimageData) == 0 && len(backimageData) == 0 {
-			// both images are being nulled. Destroy them.
-			if err := qb.DestroyMovieImages(movie.ID, tx); err != nil {
-				tx.Rollback()
-				return nil, err
-			}
-		} else {
-			// HACK - if front image is null and back image is not null, then set the front image
-			// to the default image since we can't have a null front image and a non-null back image
-			if frontimageData == nil && backimageData != nil {
-				_, frontimageData, _ = utils.ProcessBase64Image(models.DefaultMovieImage)
-			}
-
-			if err := qb.UpdateMovieImages(movie.ID, frontimageData, backimageData, tx); err != nil {
-				_ = tx.Rollback()
-				return nil, err
-			}
-		}
-	}
-
-	// Commit
-	if err := tx.Commit(); err != nil {
-		return nil, err
-	}
-
-	return movie, nil
+	r.hookExecutor.ExecutePostHooks(ctx, movie.ID, plugin.MovieUpdatePost, input, translator.getFields())
+	return r.getMovie(ctx, movie.ID)
 }
 
 func (r *mutationResolver) MovieDestroy(ctx context.Context, input models.MovieDestroyInput) (bool, error) {
-	qb := models.NewMovieQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
-	if err := qb.Destroy(input.ID, tx); err != nil {
-		_ = tx.Rollback()
+	id, err := strconv.Atoi(input.ID)
+	if err != nil {
 		return false, err
 	}
-	if err := tx.Commit(); err != nil {
+
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		return repo.Movie().Destroy(id)
+	}); err != nil {
 		return false, err
 	}
+
+	r.hookExecutor.ExecutePostHooks(ctx, id, plugin.MovieDestroyPost, input, nil)
+
+	return true, nil
+}
+
+func (r *mutationResolver) MoviesDestroy(ctx context.Context, movieIDs []string) (bool, error) {
+	ids, err := utils.StringSliceToIntSlice(movieIDs)
+	if err != nil {
+		return false, err
+	}
+
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Movie()
+		for _, id := range ids {
+			if err := qb.Destroy(id); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return false, err
+	}
+
+	for _, id := range ids {
+		r.hookExecutor.ExecutePostHooks(ctx, id, plugin.MovieDestroyPost, movieIDs, nil)
+	}
+
 	return true, nil
 }

pkg/api/resolver_mutation_performer.go

@@ -3,14 +3,27 @@ package api
 import (
 	"context"
 	"database/sql"
+	"fmt"
 	"strconv"
 	"time"
 
-	"github.com/stashapp/stash/pkg/database"
 	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/performer"
+	"github.com/stashapp/stash/pkg/plugin"
 	"github.com/stashapp/stash/pkg/utils"
 )
 
+func (r *mutationResolver) getPerformer(ctx context.Context, id int) (ret *models.Performer, err error) {
+	if err := r.withReadTxn(ctx, func(repo models.ReaderRepository) error {
+		ret, err = repo.Performer().Find(id)
+		return err
+	}); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
 func (r *mutationResolver) PerformerCreate(ctx context.Context, input models.PerformerCreateInput) (*models.Performer, error) {
 	// generate checksum from performer name rather than image
 	checksum := utils.MD5FromString(input.Name)
@@ -19,7 +32,7 @@ func (r *mutationResolver) PerformerCreate(ctx context.Context, input models.Per
 	var err error
 
 	if input.Image != nil {
-		_, imageData, err = utils.ProcessBase64Image(*input.Image)
+		imageData, err = utils.ProcessImageInput(*input.Image)
 	}
 
 	if err != nil {
@@ -84,180 +97,350 @@ func (r *mutationResolver) PerformerCreate(ctx context.Context, input models.Per
 	} else {
 		newPerformer.Favorite = sql.NullBool{Bool: false, Valid: true}
 	}
+	if input.Rating != nil {
+		newPerformer.Rating = sql.NullInt64{Int64: int64(*input.Rating), Valid: true}
+	} else {
+		newPerformer.Rating = sql.NullInt64{Valid: false}
+	}
+	if input.Details != nil {
+		newPerformer.Details = sql.NullString{String: *input.Details, Valid: true}
+	}
+	if input.DeathDate != nil {
+		newPerformer.DeathDate = models.SQLiteDate{String: *input.DeathDate, Valid: true}
+	}
+	if input.HairColor != nil {
+		newPerformer.HairColor = sql.NullString{String: *input.HairColor, Valid: true}
+	}
+	if input.Weight != nil {
+		weight := int64(*input.Weight)
+		newPerformer.Weight = sql.NullInt64{Int64: weight, Valid: true}
+	}
+
+	if err := performer.ValidateDeathDate(nil, input.Birthdate, input.DeathDate); err != nil {
+		if err != nil {
+			return nil, err
+		}
+	}
 
 	// Start the transaction and save the performer
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewPerformerQueryBuilder()
-	jqb := models.NewJoinsQueryBuilder()
+	var performer *models.Performer
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Performer()
 
-	performer, err := qb.Create(newPerformer, tx)
-	if err != nil {
-		_ = tx.Rollback()
-		return nil, err
-	}
-
-	// update image table
-	if len(imageData) > 0 {
-		if err := qb.UpdatePerformerImage(performer.ID, imageData, tx); err != nil {
-			_ = tx.Rollback()
-			return nil, err
+		performer, err = qb.Create(newPerformer)
+		if err != nil {
+			return err
 		}
-	}
 
-	// Save the stash_ids
-	if input.StashIds != nil {
-		var stashIDJoins []models.StashID
-		for _, stashID := range input.StashIds {
-			newJoin := models.StashID{
-				StashID:  stashID.StashID,
-				Endpoint: stashID.Endpoint,
+		if len(input.TagIds) > 0 {
+			if err := r.updatePerformerTags(qb, performer.ID, input.TagIds); err != nil {
+				return err
 			}
-			stashIDJoins = append(stashIDJoins, newJoin)
 		}
-		if err := jqb.UpdatePerformerStashIDs(performer.ID, stashIDJoins, tx); err != nil {
-			return nil, err
-		}
-	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+		// update image table
+		if len(imageData) > 0 {
+			if err := qb.UpdateImage(performer.ID, imageData); err != nil {
+				return err
+			}
+		}
+
+		// Save the stash_ids
+		if input.StashIds != nil {
+			stashIDJoins := models.StashIDsFromInput(input.StashIds)
+			if err := qb.UpdateStashIDs(performer.ID, stashIDJoins); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
 		return nil, err
 	}
 
-	return performer, nil
+	r.hookExecutor.ExecutePostHooks(ctx, performer.ID, plugin.PerformerCreatePost, input, nil)
+	return r.getPerformer(ctx, performer.ID)
 }
 
 func (r *mutationResolver) PerformerUpdate(ctx context.Context, input models.PerformerUpdateInput) (*models.Performer, error) {
 	// Populate performer from the input
 	performerID, _ := strconv.Atoi(input.ID)
-	updatedPerformer := models.Performer{
+	updatedPerformer := models.PerformerPartial{
 		ID:        performerID,
-		UpdatedAt: models.SQLiteTimestamp{Timestamp: time.Now()},
+		UpdatedAt: &models.SQLiteTimestamp{Timestamp: time.Now()},
 	}
+
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
+	}
+
 	var imageData []byte
 	var err error
-	imageIncluded := wasFieldIncluded(ctx, "image")
+	imageIncluded := translator.hasField("image")
 	if input.Image != nil {
-		_, imageData, err = utils.ProcessBase64Image(*input.Image)
+		imageData, err = utils.ProcessImageInput(*input.Image)
 		if err != nil {
 			return nil, err
 		}
 	}
+
 	if input.Name != nil {
 		// generate checksum from performer name rather than image
 		checksum := utils.MD5FromString(*input.Name)
 
-		updatedPerformer.Name = sql.NullString{String: *input.Name, Valid: true}
-		updatedPerformer.Checksum = checksum
-	}
-	if input.URL != nil {
-		updatedPerformer.URL = sql.NullString{String: *input.URL, Valid: true}
-	}
-	if input.Gender != nil {
-		updatedPerformer.Gender = sql.NullString{String: input.Gender.String(), Valid: true}
-	}
-	if input.Birthdate != nil {
-		updatedPerformer.Birthdate = models.SQLiteDate{String: *input.Birthdate, Valid: true}
-	}
-	if input.Ethnicity != nil {
-		updatedPerformer.Ethnicity = sql.NullString{String: *input.Ethnicity, Valid: true}
-	}
-	if input.Country != nil {
-		updatedPerformer.Country = sql.NullString{String: *input.Country, Valid: true}
-	}
-	if input.EyeColor != nil {
-		updatedPerformer.EyeColor = sql.NullString{String: *input.EyeColor, Valid: true}
-	}
-	if input.Height != nil {
-		updatedPerformer.Height = sql.NullString{String: *input.Height, Valid: true}
-	}
-	if input.Measurements != nil {
-		updatedPerformer.Measurements = sql.NullString{String: *input.Measurements, Valid: true}
-	}
-	if input.FakeTits != nil {
-		updatedPerformer.FakeTits = sql.NullString{String: *input.FakeTits, Valid: true}
-	}
-	if input.CareerLength != nil {
-		updatedPerformer.CareerLength = sql.NullString{String: *input.CareerLength, Valid: true}
-	}
-	if input.Tattoos != nil {
-		updatedPerformer.Tattoos = sql.NullString{String: *input.Tattoos, Valid: true}
-	}
-	if input.Piercings != nil {
-		updatedPerformer.Piercings = sql.NullString{String: *input.Piercings, Valid: true}
-	}
-	if input.Aliases != nil {
-		updatedPerformer.Aliases = sql.NullString{String: *input.Aliases, Valid: true}
-	}
-	if input.Twitter != nil {
-		updatedPerformer.Twitter = sql.NullString{String: *input.Twitter, Valid: true}
-	}
-	if input.Instagram != nil {
-		updatedPerformer.Instagram = sql.NullString{String: *input.Instagram, Valid: true}
-	}
-	if input.Favorite != nil {
-		updatedPerformer.Favorite = sql.NullBool{Bool: *input.Favorite, Valid: true}
-	} else {
-		updatedPerformer.Favorite = sql.NullBool{Bool: false, Valid: true}
+		updatedPerformer.Name = &sql.NullString{String: *input.Name, Valid: true}
+		updatedPerformer.Checksum = &checksum
 	}
 
-	// Start the transaction and save the performer
-	tx := database.DB.MustBeginTx(ctx, nil)
-	qb := models.NewPerformerQueryBuilder()
-	jqb := models.NewJoinsQueryBuilder()
+	updatedPerformer.URL = translator.nullString(input.URL, "url")
 
-	performer, err := qb.Update(updatedPerformer, tx)
-	if err != nil {
-		tx.Rollback()
-		return nil, err
-	}
-
-	// update image table
-	if len(imageData) > 0 {
-		if err := qb.UpdatePerformerImage(performer.ID, imageData, tx); err != nil {
-			tx.Rollback()
-			return nil, err
-		}
-	} else if imageIncluded {
-		// must be unsetting
-		if err := qb.DestroyPerformerImage(performer.ID, tx); err != nil {
-			tx.Rollback()
-			return nil, err
+	if translator.hasField("gender") {
+		if input.Gender != nil {
+			updatedPerformer.Gender = &sql.NullString{String: input.Gender.String(), Valid: true}
+		} else {
+			updatedPerformer.Gender = &sql.NullString{String: "", Valid: false}
 		}
 	}
 
-	// Save the stash_ids
-	if input.StashIds != nil {
-		var stashIDJoins []models.StashID
-		for _, stashID := range input.StashIds {
-			newJoin := models.StashID{
-				StashID:  stashID.StashID,
-				Endpoint: stashID.Endpoint,
+	updatedPerformer.Birthdate = translator.sqliteDate(input.Birthdate, "birthdate")
+	updatedPerformer.Country = translator.nullString(input.Country, "country")
+	updatedPerformer.EyeColor = translator.nullString(input.EyeColor, "eye_color")
+	updatedPerformer.Measurements = translator.nullString(input.Measurements, "measurements")
+	updatedPerformer.Height = translator.nullString(input.Height, "height")
+	updatedPerformer.Ethnicity = translator.nullString(input.Ethnicity, "ethnicity")
+	updatedPerformer.FakeTits = translator.nullString(input.FakeTits, "fake_tits")
+	updatedPerformer.CareerLength = translator.nullString(input.CareerLength, "career_length")
+	updatedPerformer.Tattoos = translator.nullString(input.Tattoos, "tattoos")
+	updatedPerformer.Piercings = translator.nullString(input.Piercings, "piercings")
+	updatedPerformer.Aliases = translator.nullString(input.Aliases, "aliases")
+	updatedPerformer.Twitter = translator.nullString(input.Twitter, "twitter")
+	updatedPerformer.Instagram = translator.nullString(input.Instagram, "instagram")
+	updatedPerformer.Favorite = translator.nullBool(input.Favorite, "favorite")
+	updatedPerformer.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedPerformer.Details = translator.nullString(input.Details, "details")
+	updatedPerformer.DeathDate = translator.sqliteDate(input.DeathDate, "death_date")
+	updatedPerformer.HairColor = translator.nullString(input.HairColor, "hair_color")
+	updatedPerformer.Weight = translator.nullInt64(input.Weight, "weight")
+
+	// Start the transaction and save the p
+	var p *models.Performer
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Performer()
+
+		// need to get existing performer
+		existing, err := qb.Find(updatedPerformer.ID)
+		if err != nil {
+			return err
+		}
+
+		if existing == nil {
+			return fmt.Errorf("performer with id %d not found", updatedPerformer.ID)
+		}
+
+		if err := performer.ValidateDeathDate(existing, input.Birthdate, input.DeathDate); err != nil {
+			if err != nil {
+				return err
 			}
-			stashIDJoins = append(stashIDJoins, newJoin)
 		}
-		if err := jqb.UpdatePerformerStashIDs(performerID, stashIDJoins, tx); err != nil {
-			return nil, err
-		}
-	}
 
-	// Commit
-	if err := tx.Commit(); err != nil {
+		p, err = qb.Update(updatedPerformer)
+		if err != nil {
+			return err
+		}
+
+		// Save the tags
+		if translator.hasField("tag_ids") {
+			if err := r.updatePerformerTags(qb, p.ID, input.TagIds); err != nil {
+				return err
+			}
+		}
+
+		// update image table
+		if len(imageData) > 0 {
+			if err := qb.UpdateImage(p.ID, imageData); err != nil {
+				return err
+			}
+		} else if imageIncluded {
+			// must be unsetting
+			if err := qb.DestroyImage(p.ID); err != nil {
+				return err
+			}
+		}
+
+		// Save the stash_ids
+		if translator.hasField("stash_ids") {
+			stashIDJoins := models.StashIDsFromInput(input.StashIds)
+			if err := qb.UpdateStashIDs(performerID, stashIDJoins); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
 		return nil, err
 	}
 
-	return performer, nil
+	r.hookExecutor.ExecutePostHooks(ctx, p.ID, plugin.PerformerUpdatePost, input, translator.getFields())
+	return r.getPerformer(ctx, p.ID)
+}
+
+func (r *mutationResolver) updatePerformerTags(qb models.PerformerReaderWriter, performerID int, tagsIDs []string) error {
+	ids, err := utils.StringSliceToIntSlice(tagsIDs)
+	if err != nil {
+		return err
+	}
+	return qb.UpdateTags(performerID, ids)
+}
+
+func (r *mutationResolver) BulkPerformerUpdate(ctx context.Context, input models.BulkPerformerUpdateInput) ([]*models.Performer, error) {
+	performerIDs, err := utils.StringSliceToIntSlice(input.Ids)
+	if err != nil {
+		return nil, err
+	}
+
+	// Populate performer from the input
+	updatedTime := time.Now()
+
+	translator := changesetTranslator{
+		inputMap: getUpdateInputMap(ctx),
+	}
+
+	updatedPerformer := models.PerformerPartial{
+		UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
+	}
+
+	updatedPerformer.URL = translator.nullString(input.URL, "url")
+	updatedPerformer.Birthdate = translator.sqliteDate(input.Birthdate, "birthdate")
+	updatedPerformer.Ethnicity = translator.nullString(input.Ethnicity, "ethnicity")
+	updatedPerformer.Country = translator.nullString(input.Country, "country")
+	updatedPerformer.EyeColor = translator.nullString(input.EyeColor, "eye_color")
+	updatedPerformer.Height = translator.nullString(input.Height, "height")
+	updatedPerformer.Measurements = translator.nullString(input.Measurements, "measurements")
+	updatedPerformer.FakeTits = translator.nullString(input.FakeTits, "fake_tits")
+	updatedPerformer.CareerLength = translator.nullString(input.CareerLength, "career_length")
+	updatedPerformer.Tattoos = translator.nullString(input.Tattoos, "tattoos")
+	updatedPerformer.Piercings = translator.nullString(input.Piercings, "piercings")
+	updatedPerformer.Aliases = translator.nullString(input.Aliases, "aliases")
+	updatedPerformer.Twitter = translator.nullString(input.Twitter, "twitter")
+	updatedPerformer.Instagram = translator.nullString(input.Instagram, "instagram")
+	updatedPerformer.Favorite = translator.nullBool(input.Favorite, "favorite")
+	updatedPerformer.Rating = translator.nullInt64(input.Rating, "rating")
+	updatedPerformer.Details = translator.nullString(input.Details, "details")
+	updatedPerformer.DeathDate = translator.sqliteDate(input.DeathDate, "death_date")
+	updatedPerformer.HairColor = translator.nullString(input.HairColor, "hair_color")
+	updatedPerformer.Weight = translator.nullInt64(input.Weight, "weight")
+
+	if translator.hasField("gender") {
+		if input.Gender != nil {
+			updatedPerformer.Gender = &sql.NullString{String: input.Gender.String(), Valid: true}
+		} else {
+			updatedPerformer.Gender = &sql.NullString{String: "", Valid: false}
+		}
+	}
+
+	ret := []*models.Performer{}
+
+	// Start the transaction and save the scene marker
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Performer()
+
+		for _, performerID := range performerIDs {
+			updatedPerformer.ID = performerID
+
+			// need to get existing performer
+			existing, err := qb.Find(performerID)
+			if err != nil {
+				return err
+			}
+
+			if existing == nil {
+				return fmt.Errorf("performer with id %d not found", performerID)
+			}
+
+			if err := performer.ValidateDeathDate(existing, input.Birthdate, input.DeathDate); err != nil {
+				return err
+			}
+
+			performer, err := qb.Update(updatedPerformer)
+			if err != nil {
+				return err
+			}
+
+			ret = append(ret, performer)
+
+			// Save the tags
+			if translator.hasField("tag_ids") {
+				tagIDs, err := adjustTagIDs(qb, performerID, *input.TagIds)
+				if err != nil {
+					return err
+				}
+
+				if err := qb.UpdateTags(performerID, tagIDs); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	// execute post hooks outside of txn
+	var newRet []*models.Performer
+	for _, performer := range ret {
+		r.hookExecutor.ExecutePostHooks(ctx, performer.ID, plugin.ImageUpdatePost, input, translator.getFields())
+
+		performer, err = r.getPerformer(ctx, performer.ID)
+		if err != nil {
+			return nil, err
+		}
+
+		newRet = append(newRet, performer)
+	}
+
+	return newRet, nil
 }
 
 func (r *mutationResolver) PerformerDestroy(ctx context.Context, input models.PerformerDestroyInput) (bool, error) {
-	qb := models.NewPerformerQueryBuilder()
-	tx := database.DB.MustBeginTx(ctx, nil)
-	if err := qb.Destroy(input.ID, tx); err != nil {
-		_ = tx.Rollback()
+	id, err := strconv.Atoi(input.ID)
+	if err != nil {
 		return false, err
 	}
-	if err := tx.Commit(); err != nil {
+
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		return repo.Performer().Destroy(id)
+	}); err != nil {
 		return false, err
 	}
+
+	r.hookExecutor.ExecutePostHooks(ctx, id, plugin.PerformerDestroyPost, input, nil)
+
+	return true, nil
+}
+
+func (r *mutationResolver) PerformersDestroy(ctx context.Context, performerIDs []string) (bool, error) {
+	ids, err := utils.StringSliceToIntSlice(performerIDs)
+	if err != nil {
+		return false, err
+	}
+
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.Performer()
+		for _, id := range ids {
+			if err := qb.Destroy(id); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return false, err
+	}
+
+	for _, id := range ids {
+		r.hookExecutor.ExecutePostHooks(ctx, id, plugin.PerformerDestroyPost, performerIDs, nil)
+	}
+
 	return true, nil
 }

pkg/api/resolver_mutation_plugin.go

@@ -2,44 +2,20 @@ package api
 
 import (
 	"context"
-	"net/http"
 
 	"github.com/stashapp/stash/pkg/logger"
 	"github.com/stashapp/stash/pkg/manager"
-	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/models"
-	"github.com/stashapp/stash/pkg/plugin/common"
 )
 
 func (r *mutationResolver) RunPluginTask(ctx context.Context, pluginID string, taskName string, args []*models.PluginArgInput) (string, error) {
-	currentUser := getCurrentUserID(ctx)
-
-	var cookie *http.Cookie
-	var err error
-	if currentUser != nil {
-		cookie, err = createSessionCookie(*currentUser)
-		if err != nil {
-			return "", err
-		}
-	}
-
-	serverConnection := common.StashServerConnection{
-		Scheme:        "http",
-		Port:          config.GetPort(),
-		SessionCookie: cookie,
-		Dir:           config.GetConfigPath(),
-	}
-
-	if HasTLSConfig() {
-		serverConnection.Scheme = "https"
-	}
-
-	manager.GetInstance().RunPluginTask(pluginID, taskName, args, serverConnection)
+	m := manager.GetInstance()
+	m.RunPluginTask(ctx, pluginID, taskName, args)
 	return "todo", nil
 }
 
 func (r *mutationResolver) ReloadPlugins(ctx context.Context) (bool, error) {
-	err := manager.GetInstance().PluginCache.ReloadPlugins()
+	err := manager.GetInstance().PluginCache.LoadPlugins()
 	if err != nil {
 		logger.Errorf("Error reading plugin configs: %s", err.Error())
 	}

pkg/api/resolver_mutation_saved_filter.go

@@ -0,0 +1,89 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/stashapp/stash/pkg/models"
+)
+
+func (r *mutationResolver) SaveFilter(ctx context.Context, input models.SaveFilterInput) (ret *models.SavedFilter, err error) {
+	if strings.TrimSpace(input.Name) == "" {
+		return nil, errors.New("name must be non-empty")
+	}
+
+	var id *int
+	if input.ID != nil {
+		idv, err := strconv.Atoi(*input.ID)
+		if err != nil {
+			return nil, err
+		}
+		id = &idv
+	}
+
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		f := models.SavedFilter{
+			Mode:   input.Mode,
+			Name:   input.Name,
+			Filter: input.Filter,
+		}
+		if id == nil {
+			ret, err = repo.SavedFilter().Create(f)
+		} else {
+			f.ID = *id
+			ret, err = repo.SavedFilter().Update(f)
+		}
+		return err
+	}); err != nil {
+		return nil, err
+	}
+	return ret, err
+}
+
+func (r *mutationResolver) DestroySavedFilter(ctx context.Context, input models.DestroyFilterInput) (bool, error) {
+	id, err := strconv.Atoi(input.ID)
+	if err != nil {
+		return false, err
+	}
+
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		return repo.SavedFilter().Destroy(id)
+	}); err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+func (r *mutationResolver) SetDefaultFilter(ctx context.Context, input models.SetDefaultFilterInput) (bool, error) {
+	if err := r.withTxn(ctx, func(repo models.Repository) error {
+		qb := repo.SavedFilter()
+
+		if input.Filter == nil {
+			// clearing
+			def, err := qb.FindDefault(input.Mode)
+			if err != nil {
+				return err
+			}
+
+			if def != nil {
+				return qb.Destroy(def.ID)
+			}
+
+			return nil
+		}
+
+		_, err := qb.SetDefault(models.SavedFilter{
+			Mode:   input.Mode,
+			Filter: *input.Filter,
+		})
+
+		return err
+	}); err != nil {
+		return false, err
+	}
+
+	return true, nil
+}