feat: add Dockerfile publishing

Author: Nickersoft

.dockerignore

@@ -0,0 +1,11 @@
+target/
+.git/
+.gitignore
+.dockerignore
+.mise/
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local

.github/workflows/docker.yml

@@ -0,0 +1,52 @@
+name: Build and Publish Docker Image
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'lib**[0-9]+.[0-9]+.[0-9]'
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Determine tags
+        id: tags
+        run: |
+          IMAGE="${{ secrets.DOCKERHUB_USERNAME }}/odict"
+          TAGS="${IMAGE}:latest"
+          
+          if [[ "${{ github.ref }}" == refs/tags/lib* ]]; then
+            TAG_NAME=${GITHUB_REF#refs/tags/}
+            # Tag with the full tag name (e.g., lib/1.2.3) and also latest
+            TAGS="${IMAGE}:${TAG_NAME},${TAGS}"
+          fi
+          
+          echo "tags=${TAGS}" >> $GITHUB_OUTPUT
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.tags.outputs.tags }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+

Cargo.lock

@@ -1,14 +1,21 @@
-ARG ODICT_VERSION=2.1.0
-
-FROM debian:slim
+ARG ODICT_VERSION=3.2.2
 
 ARG ODICT_VERSION
-ENV ODICT_VERSION=${ODICT_VERSION}
 
-RUN curl -fsSL https://github.com/TheOpenDictionary/odict/releases/download/cli%2F${ODICT_VERSION}/odict-cli-installer.sh | sh
+FROM jdxcode/mise AS builder
+
+SHELL ["/bin/bash", "-c"]
+
+WORKDIR /odict
+COPY . .
+
+RUN mise trust -y
+RUN mise install rust
+RUN mise run build --release 
+
+FROM debian:latest
 
-WORKDIR /dictionaries
-VOLUME /dictionaries
+COPY --from=builder /odict/target/release/odict /usr/local/bin/odict
 
 ENTRYPOINT ["odict", "serve"]
-CMD []
+CMD []

Dockerfile

@@ -15,7 +15,7 @@ use crate::get_lookup_entries;
 
 #[derive(Debug, Deserialize)]
 pub struct LookupRequest {
-    queries: String,
+    q: String,
     follow: Option<bool>,
     split: Option<usize>,
 }
@@ -59,7 +59,7 @@ async fn handle_lookup(
     dictionary_cache: Data<crate::serve::DictionaryCache>,
 ) -> Result<impl Responder, LookupError> {
     let LookupRequest {
-        queries: raw_queries,
+        q: raw_queries,
         follow,
         split,
     } = params.0;

cli/src/serve/lookup.rs

@@ -105,21 +105,23 @@ impl DictionaryCache {
     pub async fn get(&self, key: &str) -> anyhow::Result<Option<Arc<OpenDictionary>>> {
         {
             let cache = self.cache.read().unwrap();
+
             if let Some(file) = cache.peek(key) {
                 // Return a clone of the Arc (cheap operation)
                 return Ok(Some(Arc::clone(file)));
             }
         }
 
         // Not in cache, need to load it
-        if let Some(path) = self.dictionaries.get(key) {
-            let dict = OpenDictionary::from_path(path.to_string_lossy().as_ref())?;
+        if let Some(dict) = self.dictionaries.get(key) {
+            let dict = OpenDictionary::load(dict.to_string_lossy().as_ref()).await?;
 
             // Now get a write lock to update the cache
             let mut cache = self.cache.write().unwrap();
 
             // Wrap in Arc before putting in cache
             let arc_dict = Arc::new(dict);
+
             cache.put(String::from(key), Arc::clone(&arc_dict));
 
             return Ok(Some(arc_dict));
@@ -174,7 +176,7 @@ pub async fn serve<'a>(ctx: &mut CLIContext<'a>, args: &ServeArgs) -> anyhow::Re
             .service(search::handle_search)
             .service(tokenize::handle_tokenize)
     })
-    .bind(("127.0.0.1", *port))?
+    .bind(("0.0.0.0", *port))?
     .run()
     .await?;
 

cli/src/serve/mod.rs

@@ -10,7 +10,7 @@ use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 pub struct SearchRequest {
-    query: String,
+    q: String,
     limit: Option<usize>,
 }
 
@@ -52,7 +52,7 @@ async fn handle_search(
     dict: Path<String>,
     dictionary_cache: Data<crate::serve::DictionaryCache>,
 ) -> Result<impl Responder, SearchError> {
-    let SearchRequest { query, limit } = params.0;
+    let SearchRequest { q, limit } = params.0;
 
     let dictionary_name = dict.into_inner();
 
@@ -73,7 +73,7 @@ async fn handle_search(
         })?;
 
     let entries = dictionary
-        .search(&query, SearchOptions::default().limit(limit.unwrap_or(10)))
+        .search(&q, SearchOptions::default().limit(limit.unwrap_or(10)))
         .map_err(|e| SearchError::SearchError {
             message: e.to_string(),
         })?;

cli/src/serve/search.rs

@@ -55,20 +55,21 @@ async fn handle_tokenize(
     let TokenizeRequest { text, follow } = params.0;
 
     let dictionary_name = dict.into_inner();
+    println!("dictionary_name: {}", dictionary_name);
 
     let file = dictionary_cache
         .get(&dictionary_name)
         .await
-        .map_err(|_e| TokenizeError::DictionaryReadError {
-            name: dictionary_name.to_string(),
+        .map_err(|e| TokenizeError::DictionaryReadError {
+            name: format!("{}: {}", dictionary_name, e),
         })?
         .ok_or(TokenizeError::DictionaryNotFound {
             name: dictionary_name.to_string(),
         })?;
 
     let dictionary = file
         .contents()
-        .map_err(|_e| TokenizeError::DictionaryReadError {
+        .map_err(|_| TokenizeError::DictionaryReadError {
             name: dictionary_name.to_string(),
         })?;