win64_release.yml

env:
    SQLITE_VERSION: '3410200'
    SQLITE_RELEASE_YEAR: '2023'
    PYTHON_VERSION: '3.9'
    ICU_VER: '74'
    ICU_URL: https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-icu-74.2-1-any.pkg.tar.zst
    MINGW_DIR: ../Qt/Tools/mingw810_64
    PORTABLE_DIR: output/portable/SQLiteStudio
    INSTALLBUILDER_DIR: ../ib
    MINGW_URL: https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/tools_mingw/qt.tools.win64_mingw810/8.1.0-1-202004170606x86_64-8.1.0-release-posix-seh-rt_v6-rev0.7z
    INSTALLBUILDER_URL: https://releases.installbuilder.com/installbuilder/installbuilder-enterprise-23.4.0-windows-x64-installer.exe

name: Windows 64-bit release build

on:
    workflow_dispatch:
        inputs:
          use_ccache:
            description: 'Use ccache (for workflow debugging only!)'
            required: false
            type: boolean
    schedule:
        - cron: '0 2 * * 1' # run at 2 AM UTC every Monday
    repository_dispatch:
        types: [win64_release]

jobs:
    build:
        runs-on: windows-2019

        strategy:
          fail-fast: false
          matrix:
            qt_version:
              - "5.15.2"
              - "5.15.12"

        steps:
            - name: Configure environment
              shell: bash
              run: |
                {
                    case ${{ matrix.qt_version }} in
                        5.15.2) echo QT_FROM_PACKAGES=0
                                echo QT_ARCH=win64_mingw81 ;;
                        *) echo QT_FROM_PACKAGES=1 ;;
                    esac
                    echo TARGET_ARCH=x86_64
                    echo MINGWxx=mingw64
                    echo CCACHE_COMMAND="$HOME/.cargo/bin/ccache.exe"
                } >> $GITHUB_ENV

            - uses: msys2/setup-msys2@v2
              if: env.QT_FROM_PACKAGES == 1
              with:
                msystem: MINGW64
                location: d:/
                install: >
                  mingw-w64-${{ env.TARGET_ARCH }}-gcc
                  mingw-w64-${{ env.TARGET_ARCH }}-make
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-base
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-declarative
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-imageformats
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-script
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-svg
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-tools
                  mingw-w64-${{ env.TARGET_ARCH }}-qt5-winextras
                  mingw-w64-${{ env.TARGET_ARCH }}-wineditline
                  unzip
                update: ${{ env.QT_FROM_PACKAGES == 1 }}

            - name: Configure shell
              run: |
                mkdir "$env:USERPROFILE/bin" -ea 0
                echo "$env:USERPROFILE/bin" >> $env:GITHUB_PATH
                if ( "$env:QT_FROM_PACKAGES" -eq 1 ) {
                    echo '@msys2.cmd %*' > "$env:USERPROFILE/bin/bash_or_msys2.cmd"
                } else {
                    echo '@bash -eo pipefail %*' > "$env:USERPROFILE/bin/bash_or_msys2.cmd"
                }

            - name: Configure Qt from packages
              if: env.QT_FROM_PACKAGES == 1
              shell: msys2 {0}
              run: |
                set -x
                qt_version_local="$(pacman -Si mingw-w64-$TARGET_ARCH-qt5-base | awk '/Version/ {print $3}')"
                case "$qt_version_local" in
                    ${{ matrix.qt_version }}*) ;;
                    *) echo "Repos have $qt_version_local, can't install ${{ matrix.qt_version }} from repos"; exit 1 ;;
                esac
                echo 'd:\msys64\$MINGWxx\bin' >> $GITHUB_PATH
                tee -a $GITHUB_ENV <<EOF_ENV
                ICU_FLAGS=-licuio -licuin -licuuc -licudt
                ICU_LIBDIR=/d/msys64/$MINGWxx/bin
                QMAKE_EXTRA_FLAGS=INCLUDEPATH+=D:/msys64/$MINGWxx/include/editline
                QT5_LIBDIR=/d/msys64/$MINGWxx/bin
                QT5_PLUGINDIR=/d/msys64/$MINGWxx/share/qt5/plugins
                ZLIB_FLAGS=-lz
                EOF_ENV

            - name: Cache Qt
              if: env.QT_FROM_PACKAGES == 0
              id: cache-qt
              uses: actions/cache@v3
              with:
                path: ${{ github.workspace }}\..\Qt
                key: ${{ runner.os }}-${{ matrix.qt_version }}-Qt-Cache

            - name: Install Qt
              if: env.QT_FROM_PACKAGES == 0
              uses: jurplel/install-qt-action@v3
              with:
                cache: true
                version: ${{ matrix.qt_version }}
                host: 'windows'
                arch: ${{ env.QT_ARCH }}
                # jurplel/install-qt-action has a bug due to which we cannot use ${{ github.workspace }} for the "dir" property, because it will fail.
                dir: 'D:/'
                setup-python: 'false'

            - name: Install mingw
              if: env.QT_FROM_PACKAGES == 0 && steps.cache-qt.outputs.cache-hit != 'true'
              shell: bash
              run: |
                curl -L ${{ env.MINGW_URL }} --output ../mingw.7z
                7z x -o"../Qt" ../mingw.7z
                echo "${{ env.MINGW_DIR }}/bin" >> $GITHUB_PATH

            - uses: actions/setup-python@v4
              with:
                python-version: ${{ env.PYTHON_VERSION }}
                architecture: 'x64'

            - name: Clone repo
              uses: actions/checkout@v3
              with:
                ref: ${{ github.event.client_payload.branch }}

            - name: Install dependencies
              if: env.QT_FROM_PACKAGES == 0
              shell: bash
              run: |
                7z x -o".." win_deps/win64_deps.zip
                echo "../lib" >> $GITHUB_PATH

            - name: Prepare ccache using action
              if: inputs.use_ccache || false
              uses: hendrikmuhs/ccache-action@v1.2
              with:
                key: win64-qt${{ matrix.qt_version }}-release
                max-size: "24M"

            - name: Configure ccache (or not ccache)
              shell: bash_or_msys2 {0}
              run: |
                if [ ${{ inputs.use_ccache || false }} = false ]; then
                    echo GCC_COMMAND="$(which gcc.exe)"
                    echo GXX_COMMAND="$(which g++.exe)"
                else
                    echo GCC_COMMAND="$CCACHE_COMMAND gcc.exe"
                    echo GXX_COMMAND="$CCACHE_COMMAND g++.exe"
                fi >> $GITHUB_ENV

            - name: Install SQLite3
              shell: bash_or_msys2 {0}
              run: |
                set -x
                cd ..
                curl -L http://sqlite.org/$SQLITE_RELEASE_YEAR/sqlite-amalgamation-$SQLITE_VERSION.zip --output sqlite-amalgamation-$SQLITE_VERSION.zip
                unzip sqlite-amalgamation-$SQLITE_VERSION.zip
                cd sqlite-amalgamation-$SQLITE_VERSION
                $GCC_COMMAND sqlite3.c -Os -fpic -DWIN64 -m64 -I. -shared -o sqlite3.dll \
                    -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT \
                    -DSQLITE_ENABLE_DBSTAT_VTAB \
                    -DSQLITE_ENABLE_BYTECODE_VTAB \
                    -DSQLITE_ENABLE_COLUMN_METADATA \
                    -DSQLITE_ENABLE_EXPLAIN_COMMENTS \
                    -DSQLITE_ENABLE_FTS3 \
                    -DSQLITE_ENABLE_FTS4 \
                    -DSQLITE_ENABLE_FTS5 \
                    -DSQLITE_ENABLE_GEOPOLY \
                    -DSQLITE_ENABLE_JSON1 \
                    -DSQLITE_ENABLE_RTREE \
                    -DSQLITE_ENABLE_MATH_FUNCTIONS
                mkdir -p ../lib ../include
                cp -f sqlite3.dll ../lib/
                cp -f sqlite3.h ../include/
                cp -f sqlite3ext.h ../include/

            - name: Install extension dependencies
              if: env.QT_FROM_PACKAGES == 0
              shell: bash
              run: |
                cd ..
                curl -L "$ICU_URL" | tar -xf - --zstd
                mv mingw64 icu
                tee -a $GITHUB_ENV <<EOF_ENV
                ICU_FLAGS=-I$(pwd)/icu/include -L$(pwd)/icu/lib -licuio -licuin -licuuc -licudt
                ICU_LIBDIR=$(pwd)/icu/bin
                QT5_LIBDIR=$Qt5_Dir/bin
                QT5_PLUGINDIR=$Qt5_Dir/plugins
                ZLIB_FLAGS=-lzlib1
                EOF_ENV

            - name: Compile additional SQLite3 extensions
              shell: bash_or_msys2 {0}
              run: |
                cd ..
                mkdir ext
                curl -L http://sqlite.org/$SQLITE_RELEASE_YEAR/sqlite-src-$SQLITE_VERSION.zip --output sqlite-src-$SQLITE_VERSION.zip
                unzip sqlite-src-$SQLITE_VERSION.zip
                cd sqlite-src-$SQLITE_VERSION/ext
                FLAGS="-shared -Os -fpic -DWIN64 -m64 -I../../include -L../../lib -lsqlite3"
                for f in compress sqlar; do
                    echo "$GCC_COMMAND misc/$f.c -Imisc $ZLIB_FLAGS $FLAGS -o ../../ext/$f.dll"
                    $GCC_COMMAND misc/$f.c -Imisc $ZLIB_FLAGS $FLAGS -o ../../ext/$f.dll
                done
                for f in csv decimal eval ieee754 percentile rot13 series uint uuid zorder; do
                    echo "$GCC_COMMAND misc/$f.c -Imisc $FLAGS -o ../../ext/$f.dll"
                    $GCC_COMMAND misc/$f.c -Imisc $FLAGS -o ../../ext/$f.dll
                done
                for f in icu; do
                    echo "$GCC_COMMAND icu/$f.c $ICU_FLAGS $FLAGS -o ../../ext/$f.dll"
                    $GCC_COMMAND icu/$f.c $ICU_FLAGS $FLAGS -o ../../ext/$f.dll
                done
                ls -l ../../ext/

            - name: Prepare output dir
              shell: bash
              run: mkdir output output/build output/build/Plugins

            - name: Compile SQLiteStudio3
              working-directory: output/build
              shell: bash_or_msys2 {0}
              run: |
                qmake.exe \
                    CONFIG+=portable \
                    "QMAKE_CXX=${{ env.GXX_COMMAND }}" \
                    $QMAKE_EXTRA_FLAGS \
                    ../../SQLiteStudio3
                mingw32-make.exe -j 2

            - name: Compile Plugins
              working-directory: output/build/Plugins
              shell: bash_or_msys2 {0}
              run: |
                qmake.exe \
                    "QMAKE_CXX=${{ env.GXX_COMMAND }}" \
                    CONFIG+=portable \
                    PYTHON_VERSION=${{ env.PYTHON_VERSION }} "INCLUDEPATH+=${{ env.pythonLocation }}/include" "LIBS += -L${{ env.pythonLocation }}" \
                    ../../../Plugins
                mingw32-make.exe -j 1

            - name: Copy SQLite extensions to output dir
              shell: bash
              run: |
                cp -R ../ext output/SQLiteStudio/

            - name: Prepare portable dir
              shell: bash
              working-directory: output
              run: |
                mkdir portable
                cp -R SQLiteStudio portable/

            - name: Clean-up portable dir
              shell: bash
              run: |
                cd ${{ env.PORTABLE_DIR }}
                rm -f *.a
                rm -f plugins/*.a
                rm -f styles/*.a
                echo "ABSOLUTE_PORTABLE_DIR=`pwd`" >> $GITHUB_ENV

            - name: Prepare portable distro (Qt)
              shell: bash
              run: |
                cd "$QT5_LIBDIR"
                cp \
                    Qt5Core.dll \
                    Qt5Gui.dll \
                    Qt5Network.dll \
                    Qt5PrintSupport.dll \
                    Qt5Qml.dll \
                    Qt5Svg.dll \
                    Qt5Widgets.dll \
                    Qt5Xml.dll \
                    libgcc_s_seh-1.dll \
                    libstdc++-6.dll \
                    libwinpthread-1.dll \
                    "$ABSOLUTE_PORTABLE_DIR"
                if [ "$QT_FROM_PACKAGES" = 1 ]; then
                    cp \
                        libbrotlicommon.dll \
                        libbrotlidec.dll \
                        libbz2-1.dll \
                        libdouble-conversion.dll \
                        libfreetype-6.dll \
                        libglib-2.0-0.dll \
                        libgraphite2.dll \
                        libharfbuzz-0.dll \
                        libiconv-2.dll \
                        libintl-8.dll \
                        libmd4c.dll \
                        libpcre2-8-0.dll \
                        libpcre2-16-0.dll \
                        libpng16-16.dll \
                        libzstd.dll \
                        zlib1.dll \
                        "$ABSOLUTE_PORTABLE_DIR"
                else
                    cp qt.conf "$ABSOLUTE_PORTABLE_DIR"
                fi
                cd "$QT5_PLUGINDIR"
                mkdir -p "$ABSOLUTE_PORTABLE_DIR/iconengines"
                mkdir -p "$ABSOLUTE_PORTABLE_DIR/platforms"
                mkdir -p "$ABSOLUTE_PORTABLE_DIR/printsupport"
                mkdir -p "$ABSOLUTE_PORTABLE_DIR/styles"
                mkdir -p "$ABSOLUTE_PORTABLE_DIR/imageformats"
                cp iconengines/qsvgicon.dll "$ABSOLUTE_PORTABLE_DIR/iconengines"
                cp platforms/qwindows.dll "$ABSOLUTE_PORTABLE_DIR/platforms"
                cp styles/qwindowsvistastyle.dll "$ABSOLUTE_PORTABLE_DIR/styles"
                cp printsupport/windowsprintersupport.dll "$ABSOLUTE_PORTABLE_DIR/printsupport"
                for f in qgif qicns qico qjpeg qsvg qtga qtiff qwbmp; do cp imageformats/$f.dll "$ABSOLUTE_PORTABLE_DIR/imageformats"; done

            - name: Prepare portable distro (Deps)
              shell: bash
              run: |
                cd ../lib
                cp *.dll "$ABSOLUTE_PORTABLE_DIR"
                cd "$ICU_LIBDIR"
                cp libicuio$ICU_VER.dll libicuin$ICU_VER.dll libicuuc$ICU_VER.dll libicudt$ICU_VER.dll "$ABSOLUTE_PORTABLE_DIR"
                if [ "$QT_FROM_PACKAGES" = 1 ]; then
                    cp libcrypto-3-x64.dll libssl-3-x64.dll tcl86.dll "$ABSOLUTE_PORTABLE_DIR"
                fi

            - name: Prepare portable distro (Resources)
              shell: bash
              run: |
                cp SQLiteStudio3/guiSQLiteStudio/img/sqlitestudio.ico "$ABSOLUTE_PORTABLE_DIR"/appicon.ico
                cp SQLiteStudio3/guiSQLiteStudio/img/sqlitestudio.svg "${{ env.PORTABLE_DIR }}"/appicon.svg

            - name: Determine SQLiteStudio version
              shell: bash
              run: |
                cd $ABSOLUTE_PORTABLE_DIR
                SQLITESTUDIO_VERSION="$(./sqlitestudiocli.exe --version | cut -f 2 -d ' ')"
                [ -n "$SQLITESTUDIO_VERSION" ] || exit 1
                echo "SQLITESTUDIO_VERSION=$SQLITESTUDIO_VERSION" >> $GITHUB_ENV
                echo "PACKAGE_VERSION=$SQLITESTUDIO_VERSION-qt${{ matrix.qt_version }}" >> $GITHUB_ENV

            - name: Assemble portable package
              shell: bash
              run: |
                cd $ABSOLUTE_PORTABLE_DIR/..
                7z a -r sqlitestudio-$PACKAGE_VERSION.zip SQLiteStudio

            - name: Install the InstalBuilder
              shell: bash
              env:
                IB_LICENSE: ${{ secrets.INSTALLER_LICENSE }}
              run: |
                curl -L ${{ env.INSTALLBUILDER_URL }} --output ib.exe
                ./ib.exe --mode unattended --prefix ${{ env.INSTALLBUILDER_DIR }}
                ${{ env.INSTALLBUILDER_DIR }}/bin/builder-cli.exe --version
                echo "$IB_LICENSE" > lic.xml
                echo "INSTALLER_SRC_PREFIX=$(pwd)" >> $GITHUB_ENV
                echo "INSTALLER_BIN_PREFIX=$ABSOLUTE_PORTABLE_DIR" >> $GITHUB_ENV

            - name: Create installer package
              shell: bash
              run: |
                ${{ env.INSTALLBUILDER_DIR }}/bin/builder-cli.exe build SQLiteStudio-installer.xml \
                    --license lic.xml \
                    --setvars project.outputDirectory=$(pwd) \
                    --setvars project.version=$SQLITESTUDIO_VERSION
                ls -l
                mv SQLiteStudio-${{ env.SQLITESTUDIO_VERSION }}-windows-x64-installer.exe \
                    SQLiteStudio-$PACKAGE_VERSION-windows-x64-installer.exe \

            - name: Upload package artifact
              uses: actions/upload-artifact@v1
              with:
                name: sqlitestudio-${{ env.PACKAGE_VERSION }}.zip
                path: output/portable/sqlitestudio-${{ env.PACKAGE_VERSION }}.zip

            - name: Upload installer artifact
              uses: actions/upload-artifact@v1
              with:
                name: SQLiteStudio-${{ env.PACKAGE_VERSION }}-windows-x64-installer.exe
                path: SQLiteStudio-${{ env.PACKAGE_VERSION }}-windows-x64-installer.exe