Draft: Feature/rust support

examples/services/worker/assets/embed.go

@@ -1,4 +1,8 @@
+<<<<<<<< HEAD:internal/assets/golang/embed.go
+package golang
+========
 package assets
+>>>>>>>> main:examples/services/worker/assets/embed.go
 
 import (
 	"embed"

internal/answers/answers.go

@@ -0,0 +1,68 @@
+package answers
+
+import (
+	"github.com/somatech1/mikros-cli/internal/templates"
+)
+
+type InitSurveyAnswers struct {
+	Name          string
+	Type          string
+	Version       string
+	Product       string
+	Features      []string
+	Lifecycle     []string
+	RustLifecycle bool `survey:"lifecycle_rust"`
+
+	language           templates.Language
+	featureDefinitions map[string]*SurveyAnswersDefinitions
+	serviceDefinitions *SurveyAnswersDefinitions
+}
+
+func NewInitSurveyAnswers(language templates.Language) *InitSurveyAnswers {
+	return &InitSurveyAnswers{
+		language: language,
+	}
+}
+
+func (i *InitSurveyAnswers) Language() string {
+	return i.language.String()
+}
+
+func (i *InitSurveyAnswers) AddFeatureDefinitions(name string, answers interface{}, save bool) {
+	if i.featureDefinitions == nil {
+		i.featureDefinitions = make(map[string]*SurveyAnswersDefinitions)
+	}
+
+	i.featureDefinitions[name] = &SurveyAnswersDefinitions{
+		save:        save,
+		definitions: answers,
+	}
+}
+
+func (i *InitSurveyAnswers) SetServiceDefinitions(answers interface{}, save bool) {
+	i.serviceDefinitions = &SurveyAnswersDefinitions{
+		save:        save,
+		definitions: answers,
+	}
+}
+
+func (i *InitSurveyAnswers) ServiceDefinitions() *SurveyAnswersDefinitions {
+	return i.serviceDefinitions
+}
+
+func (i *InitSurveyAnswers) FeatureDefinitions() map[string]*SurveyAnswersDefinitions {
+	return i.featureDefinitions
+}
+
+type SurveyAnswersDefinitions struct {
+	save        bool
+	definitions interface{}
+}
+
+func (s *SurveyAnswersDefinitions) ShouldBeSaved() bool {
+	return s.save
+}
+
+func (s *SurveyAnswersDefinitions) Definitions() interface{} {
+	return s.definitions
+}

internal/assets/templates/service/rust/embed.go

@@ -0,0 +1,8 @@
+package rust
+
+import (
+	"embed"
+)
+
+//go:embed *.tmpl
+var Files embed.FS

internal/assets/templates/service/rust/main.tmpl

@@ -0,0 +1,14 @@
+mod service;
+
+use mikros::service::builder::ServiceBuilder;
+use service::Service as AppService;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let s = AppService::new();
+    let mut svc = ServiceBuilder::default()
+        {{.ServiceTypeBuilderCall}}
+        .build()?;
+
+    Ok(svc.start().await?)
+}

internal/assets/templates/service/rust/service.tmpl

@@ -0,0 +1,93 @@
+
+use std::sync::Arc;
+{{if or .IsGrpcService .IsHttpService}}
+use tonic::{Request, Response, Status};
+
+pub mod {{.ModuleName}} {
+    include!("generated/{{.ModuleName}}.rs");
+}
+{{end}}
+{{- if .IsGrpcService}}
+use {{.ModuleName}}::{{toSnake .ServiceName}}_server::{{"{"}}{{.ServiceName}}, {{.ServiceName}}Server{{"}"}};
+{{- end}}
+{{- if .IsHttpService}}
+use api::router::Router;
+{{- end}}
+{{- if or .IsScriptService .IsNativeService}}
+use mikros::errors as merrors;
+use mikros::service::context::Context;
+{{- end}}
+
+#[derive(Clone, Default)]
+pub struct Service;
+
+impl Service {
+    {{- if .IsGrpcService}}
+    pub fn new() -> {{.ServiceName}}Server<Service> {
+        let service = Arc::new(Self::default());
+        {{.ServiceName}}Server::from_arc(service)
+    }
+    {{- end}}
+    {{- if or .IsScriptService .IsNativeService}}
+    pub fn new() -> Self {
+        Self::default()
+    }
+    {{- end}}
+    {{- if .IsHttpService}}
+    pub fn new() -> Router {
+        let service = Arc::new(Self::default());
+        Router::new(service)
+    }
+    {{- end}}
+}
+
+{{if or .IsGrpcService .IsHttpService -}}{{$moduleName := .ModuleName}}
+#[tonic::async_trait]
+impl {{$moduleName}}::{{.ServiceName}} for Service {
+    {{- range .Methods}}
+    async fn {{toSnake .Name}}(
+        &self,
+        request: Request<{{$moduleName}}::{{.RequestName}}>,
+    ) -> Result<Response<{{$moduleName}}::{{.ResponseName}}>, Status> {
+        todo!()
+    }
+    {{end}}
+}
+{{- end}}
+{{- if .IsScriptService}}
+#[async_trait::async_trait]
+impl mikros::service::script::ScriptService for Service {
+    async fn run(&self, ctx: Arc<Context>) -> merrors::Result<()> {
+        todo!()
+    }
+
+    async fn cleanup(&self, ctx: Arc<Context>) {
+        todo!()
+    }
+}
+{{- end}}
+{{- if .IsNativeService}}
+#[async_trait::async_trait]
+impl mikros::service::native::NativeService for Service {
+    async fn start(&self, ctx: Arc<Context>) -> merrors::Result<()> {
+        todo!()
+    }
+
+    async fn stop(&self, ctx: Arc<Context>) {
+        todo!()
+    }
+}
+{{- end}}
+
+{{if .HasLifecycle}}
+#[async_trait::async_trait]
+impl mikros::service::lifecycle::Lifecycle for Service {
+    async fn on_start(&mut self, ctx: Arc<Context>) -> merrors::Result<()> {
+        todo!()
+    }
+
+    async fn on_finish(&self) -> merrors::Result<()> {
+        todo!()
+    }
+}
+{{- end}}