build releases

.github/workflows/release.yaml

@@ -0,0 +1,106 @@
+name: release
+
+on:
+  push:
+    tags:
+      - '*'
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  all:
+    name: All
+
+    strategy:
+      matrix:
+        target:
+          - aarch64-unknown-linux-musl
+          - armv7-unknown-linux-musleabihf
+          - x86_64-apple-darwin
+          - x86_64-pc-windows-msvc
+          - x86_64-unknown-linux-musl
+        include:
+          - target: aarch64-unknown-linux-musl
+            os: ubuntu-latest
+            native: false
+            target_rustflags: '--codegen linker=aarch64-linux-gnu-gcc'
+          - target: armv7-unknown-linux-musleabihf
+            os: ubuntu-latest
+            native: false
+            target_rustflags: '--codegen linker=arm-linux-gnueabihf-gcc'
+          - target: x86_64-apple-darwin
+            os: macos-latest
+            native: true
+            target_rustflags: ''
+          - target: x86_64-pc-windows-msvc
+            os: windows-2016
+            native: true
+            target_rustflags: ''
+          - target: x86_64-unknown-linux-musl
+            os: ubuntu-latest
+            native: true
+            target_rustflags: ''
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust Toolchain Components
+        uses: actions-rs/toolchain@v1
+        with:
+          override: true
+          target: ${{ matrix.target }}
+          toolchain: stable
+
+      - uses: Swatinem/rust-cache@v1
+
+      - name: Install AArch64 Toolchain
+        if: ${{ matrix.target == 'aarch64-unknown-linux-musl' }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install gcc-aarch64-linux-gnu
+      - name: Install ARM7 Toolchain
+        if: ${{ matrix.target == 'armv7-unknown-linux-musleabihf' }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install gcc-arm-linux-gnueabihf
+      - name: Test
+        if: matrix.native
+        run: cargo test --all --target ${{ matrix.target }}
+
+      - name: Package
+        id: package
+        env:
+          TARGET: ${{ matrix.target }}
+          REF: ${{ github.ref }}
+          OS: ${{ matrix.os }}
+          TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
+        run: ./.github/package
+        shell: bash
+
+      - name: Publish Archive
+        uses: softprops/[email protected]
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        with:
+          draft: false
+          files: ${{ steps.package.outputs.archive }}
+          prerelease: ${{ contains(github.ref_name, '-') }} ## looking for a bare semver number rather than a tagged one like 1.0.0-beta.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish Changelog
+        uses: softprops/[email protected]
+        if: >-
+          ${{
+            startsWith(github.ref, 'refs/tags/')
+            && matrix.target == 'x86_64-unknown-linux-musl'
+          }}
+        with:
+          draft: false
+          files: CHANGELOG.md
+          prerelease: ${{ contains(github.ref_name, '-') }} ## looking for a bare semver number rather than a tagged one like 1.0.0-beta.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yaml

@@ -13,7 +13,6 @@ defaults:
   run:
     shell: bash
 
-
 jobs:
   run-test:
     permissions:

cli/src/command/init.rs

@@ -1,13 +1,11 @@
-
-
-
 use anyhow::Result;
 use clap::Parser;
 use colored::Colorize;
-use ormlite::Acquire;
+use ormlite::{Acquire, Connection};
 
 
 use ormlite::Executor;
+use ormlite::postgres::PgConnection;
 
 use ormlite_core::config::{get_var_database_url};
 use crate::util::{create_connection, create_runtime};
@@ -24,19 +22,23 @@ CREATE TABLE public._sqlx_migrations (
 "#;
 
 #[derive(Parser, Debug)]
-pub struct Init {
-}
+pub struct Init {}
 
 impl Init {
     pub fn run(self) -> Result<()> {
         let runtime = create_runtime();
         let url = get_var_database_url();
-        let mut conn = create_connection(&url, &runtime)?;
-        let conn = runtime.block_on(conn.acquire())?;
-
-        runtime.block_on(conn.execute(INIT_QUERY))?;
-
-        eprintln!("{} Initialized database at {}", "SUCCESS".green(), url);
-        Ok(())
+        runtime.block_on(async {
+            let mut conn = PgConnection::connect(&url).await?;
+            let conn = conn.acquire().await?;
+            let table_exists = conn.execute("select 1 from _sqlx_migrations limit 1").await.is_ok();
+            if table_exists {
+                eprintln!("{} Database {} already initialized. No actions taken.", "SUCCESS".green(), url);
+                return Ok(());
+            }
+            conn.execute(INIT_QUERY).await?;
+            eprintln!("{} Initialized database at {}", "SUCCESS".green(), url);
+            Ok(())
+        })
     }
 }

cli/src/util.rs

@@ -1,8 +1,8 @@
 use anyhow::Error;
 use tokio::runtime::Runtime;
-use ormlite::{Connection};
-use ormlite::postgres::{PgConnection};
 
+use ormlite::Connection;
+use ormlite::postgres::PgConnection;
 
 pub(crate) fn create_runtime() -> tokio::runtime::Runtime {
     tokio::runtime::Builder::new_current_thread()

core/src/model.rs

@@ -52,6 +52,9 @@ pub trait ModelBuilder<'a, DB>
         where
             E: 'e + sqlx::Executor<'e, Database=DB>;
 
+    /// All fields that will be modified in the query.
+    fn modified_fields(&self) -> Vec<&'static str>;
+
     /// Build the model, don't insert or update it.
     fn build(self) -> Self::Model;
 }

macro/src/codegen/model_builder.rs

@@ -39,16 +39,6 @@ pub fn struct_ModelBuilder(ast: &DeriveInput, attr: &ModelMetadata) -> TokenStre
         }
     });
 
-    let build_modified_fields = attr.database_columns().map(|c| {
-        let name = &c.identifier;
-        let name_str = &c.column_name;
-        quote! {
-            if self.#name.is_some() {
-                ret.push(#name_str);
-            }
-        }
-    });
-
     let fields_none = attr.database_columns().map(|c| {
         let name = &c.identifier;
         quote! {
@@ -74,11 +64,6 @@ pub fn struct_ModelBuilder(ast: &DeriveInput, attr: &ModelMetadata) -> TokenStre
             impl<'a> #model_builder<'a> {
                 #(#methods)*
 
-                fn modified_fields(&self) -> Vec<&'static str> {
-                    let mut ret = Vec::new();
-                    #(#build_modified_fields)*
-                    ret
-                }
             }
         }
 }
@@ -122,13 +107,29 @@ pub fn impl_ModelBuilder(db: &dyn OrmliteCodegen, attr: &ModelMetadata) -> Token
     let impl_ModelBuilder__update = impl_ModelBuilder__update(db, attr);
     let impl_ModelBuilder__build = impl_ModelBuilder__build(&attr.inner);
 
+    let build_modified_fields = attr.database_columns().map(|c| {
+        let name = &c.identifier;
+        let name_str = &c.column_name;
+        quote! {
+            if self.#name.is_some() {
+                ret.push(#name_str);
+            }
+        }
+    });
+
     let db = db.database_ts();
     quote! {
         impl<'a> ::ormlite::model::ModelBuilder<'a, #db> for #partial_model<'a> {
             type Model = #model;
             #impl_ModelBuilder__insert
             #impl_ModelBuilder__update
             #impl_ModelBuilder__build
+
+            fn modified_fields(&self) -> Vec<&'static str> {
+                let mut ret = Vec::new();
+                #(#build_modified_fields)*
+                ret
+            }
         }
     }
 }