smbcloud-auth 0.3.33

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/auth"]
+resolver = "2"

data/README.md

@@ -0,0 +1,51 @@
+# smbcloud-auth Gem
+
+Ruby bindings for the smbCloud Auth SDK.
+
+## Install
+
+```bash
+gem install smbcloud-auth
+```
+
+## Usage
+
+```ruby
+require "auth"
+
+client = SmbCloud::Auth::Client.new(
+  environment: SmbCloud::Auth::Environment::PRODUCTION,
+  app_id: "app-id",
+  app_secret: "app-secret"
+)
+
+signup = client.signup(
+  email: "name@example.com",
+  password: "password123"
+)
+
+login = client.login(
+  email: "name@example.com",
+  password: "password123"
+)
+
+me = client.me(access_token: login[:access_token])
+```
+
+## API
+
+`SmbCloud::Auth::Client` exposes:
+
+- `signup(email:, password:)`
+- `login(email:, password:)`
+- `me(access_token:)`
+- `logout(access_token:)`
+- `remove(access_token:)`
+
+For simple scripting, module-level convenience wrappers are also available:
+
+- `SmbCloud::Auth.signup_with_client(...)`
+- `SmbCloud::Auth.login_with_client(...)`
+- `SmbCloud::Auth.me_with_client(...)`
+- `SmbCloud::Auth.logout_with_client(...)`
+- `SmbCloud::Auth.remove_with_client(...)`

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rb_sys/extensiontask'
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load('auth.gemspec')
+
+RbSys::ExtensionTask.new('auth', GEMSPEC) do |ext|
+  ext.lib_dir = 'lib/auth'
+end
+
+task default: :compile

data/ext/auth/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "auth"
+version = "0.3.33"
+edition = "2024"
+authors = ["Seto Elkahfi <hej@setoelkahfi.se>"]
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.7.1" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["rt-multi-thread"] }
+smbcloud-auth = { path = "./../../../../../crates/smbcloud-auth" }
+smbcloud-model = { path = "./../../../../../crates/smbcloud-model" }
+smbcloud-network = { path = "./../../../../../crates/smbcloud-network" }
+smbcloud-networking = { path = "./../../../../../crates/smbcloud-networking" }

data/ext/auth/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('auth/auth')

data/ext/auth/src/lib.rs

@@ -0,0 +1,209 @@
+use magnus::{Error, Ruby, function, prelude::*};
+use serde::Serialize;
+use smbcloud_auth::{
+    client_credentials::ClientCredentials, login::login_with_client, logout::logout_with_client,
+    me::me_with_client, remove::remove_with_client, signup::signup_with_client,
+};
+use smbcloud_model::{error_codes::ErrorResponse, login::AccountStatus, signup::SignupResult};
+use smbcloud_network::environment::Environment;
+use tokio::runtime::Runtime;
+
+#[derive(Serialize)]
+struct LoginPayload {
+    status: &'static str,
+    access_token: Option<String>,
+    error_code: Option<i32>,
+    message: Option<String>,
+}
+
+fn parse_environment(value: String) -> Result<Environment, Error> {
+    value.parse().map_err(|_| {
+        Error::new(
+            magnus::exception::arg_error(),
+            format!("invalid environment `{value}`, expected `dev` or `production`"),
+        )
+    })
+}
+
+fn with_runtime<T, F>(f: F) -> Result<T, Error>
+where
+    F: FnOnce(&Runtime) -> Result<T, Error>,
+{
+    let runtime = Runtime::new().map_err(|err| {
+        Error::new(
+            magnus::exception::runtime_error(),
+            format!("failed to initialize tokio runtime: {err}"),
+        )
+    })?;
+    f(&runtime)
+}
+
+fn to_json<T: Serialize>(value: &T) -> Result<String, Error> {
+    serde_json::to_string(value).map_err(|err| {
+        Error::new(
+            magnus::exception::runtime_error(),
+            format!("failed to serialize response: {err}"),
+        )
+    })
+}
+
+fn raise_error_response(error: ErrorResponse) -> Error {
+    let payload = serde_json::to_string(&error).unwrap_or_else(|_| {
+        "{\"error\":{\"error_code\":0,\"message\":\"Unknown error.\"}}".to_string()
+    });
+    Error::new(magnus::exception::runtime_error(), payload)
+}
+
+fn login_payload(status: AccountStatus) -> LoginPayload {
+    match status {
+        AccountStatus::NotFound => LoginPayload {
+            status: "not_found",
+            access_token: None,
+            error_code: None,
+            message: None,
+        },
+        AccountStatus::Ready { access_token } => LoginPayload {
+            status: "ready",
+            access_token: Some(access_token),
+            error_code: None,
+            message: None,
+        },
+        AccountStatus::Incomplete { status } => LoginPayload {
+            status: "incomplete",
+            access_token: None,
+            error_code: Some(status as i32),
+            message: Some(status.to_string()),
+        },
+    }
+}
+
+fn credentials<'a>(app_id: &'a str, app_secret: &'a str) -> ClientCredentials<'a> {
+    ClientCredentials { app_id, app_secret }
+}
+
+fn signup_with_client_json(
+    environment: String,
+    app_id: String,
+    app_secret: String,
+    email: String,
+    password: String,
+) -> Result<String, Error> {
+    let env = parse_environment(environment)?;
+    with_runtime(|runtime| {
+        let result: Result<SignupResult, ErrorResponse> = runtime.block_on(signup_with_client(
+            env,
+            credentials(&app_id, &app_secret),
+            email,
+            password,
+        ));
+        match result {
+            Ok(result) => to_json(&result),
+            Err(error) => Err(raise_error_response(error)),
+        }
+    })
+}
+
+fn login_with_client_json(
+    environment: String,
+    app_id: String,
+    app_secret: String,
+    email: String,
+    password: String,
+) -> Result<String, Error> {
+    let env = parse_environment(environment)?;
+    with_runtime(|runtime| {
+        let result: Result<AccountStatus, ErrorResponse> = runtime.block_on(login_with_client(
+            env,
+            credentials(&app_id, &app_secret),
+            email,
+            password,
+        ));
+        match result {
+            Ok(result) => to_json(&login_payload(result)),
+            Err(error) => Err(raise_error_response(error)),
+        }
+    })
+}
+
+fn me_with_client_json(
+    environment: String,
+    app_id: String,
+    app_secret: String,
+    access_token: String,
+) -> Result<String, Error> {
+    let env = parse_environment(environment)?;
+    with_runtime(|runtime| {
+        let result = runtime.block_on(me_with_client(
+            env,
+            credentials(&app_id, &app_secret),
+            &access_token,
+        ));
+        match result {
+            Ok(result) => to_json(&result),
+            Err(error) => Err(raise_error_response(error)),
+        }
+    })
+}
+
+fn logout_with_client_json(
+    environment: String,
+    app_id: String,
+    app_secret: String,
+    access_token: String,
+) -> Result<bool, Error> {
+    let env = parse_environment(environment)?;
+    with_runtime(|runtime| {
+        let result = runtime.block_on(logout_with_client(
+            env,
+            credentials(&app_id, &app_secret),
+            access_token,
+        ));
+        match result {
+            Ok(()) => Ok(true),
+            Err(error) => Err(raise_error_response(error)),
+        }
+    })
+}
+
+fn remove_with_client_json(
+    environment: String,
+    app_id: String,
+    app_secret: String,
+    access_token: String,
+) -> Result<bool, Error> {
+    let env = parse_environment(environment)?;
+    with_runtime(|runtime| {
+        let result = runtime.block_on(remove_with_client(
+            env,
+            credentials(&app_id, &app_secret),
+            &access_token,
+        ));
+        match result {
+            Ok(()) => Ok(true),
+            Err(error) => Err(raise_error_response(error)),
+        }
+    })
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let smbcloud = ruby.define_module("SmbCloud")?;
+    let auth = smbcloud.define_module("Auth")?;
+
+    auth.define_singleton_method(
+        "__signup_with_client",
+        function!(signup_with_client_json, 5),
+    )?;
+    auth.define_singleton_method("__login_with_client", function!(login_with_client_json, 5))?;
+    auth.define_singleton_method("__me_with_client", function!(me_with_client_json, 4))?;
+    auth.define_singleton_method(
+        "__logout_with_client",
+        function!(logout_with_client_json, 4),
+    )?;
+    auth.define_singleton_method(
+        "__remove_with_client",
+        function!(remove_with_client_json, 4),
+    )?;
+
+    Ok(())
+}

data/lib/auth/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Auth
+  VERSION = '0.3.33'
+end

data/lib/auth.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'auth/version'
+require_relative 'auth/auth'
+
+module Auth
+end
+
+module SmbCloud
+  module Auth
+    class Error < StandardError
+      attr_reader :error_code, :payload
+
+      def initialize(message = nil, error_code: nil, payload: nil)
+        super(message)
+        @error_code = error_code
+        @payload = payload
+      end
+    end
+
+    module Environment
+      DEV = 'dev'
+      PRODUCTION = 'production'
+    end
+
+    class Client
+      attr_reader :environment, :app_id, :app_secret
+
+      def initialize(environment:, app_id:, app_secret:)
+        @environment = environment
+        @app_id = app_id
+        @app_secret = app_secret
+      end
+
+      def signup(email:, password:)
+        Auth.send(:parse_json, Auth.__signup_with_client(environment, app_id, app_secret, email, password))
+      rescue RuntimeError => e
+        raise Auth.send(:normalize_error, e)
+      end
+
+      def login(email:, password:)
+        Auth.send(:parse_json, Auth.__login_with_client(environment, app_id, app_secret, email, password))
+      rescue RuntimeError => e
+        raise Auth.send(:normalize_error, e)
+      end
+
+      def me(access_token:)
+        Auth.send(:parse_json, Auth.__me_with_client(environment, app_id, app_secret, access_token))
+      rescue RuntimeError => e
+        raise Auth.send(:normalize_error, e)
+      end
+
+      def logout(access_token:)
+        Auth.__logout_with_client(environment, app_id, app_secret, access_token)
+      rescue RuntimeError => e
+        raise Auth.send(:normalize_error, e)
+      end
+
+      def remove(access_token:)
+        Auth.__remove_with_client(environment, app_id, app_secret, access_token)
+      rescue RuntimeError => e
+        raise Auth.send(:normalize_error, e)
+      end
+    end
+
+    class << self
+      def client(environment:, app_id:, app_secret:)
+        Client.new(environment:, app_id:, app_secret:)
+      end
+
+      def signup_with_client(environment:, app_id:, app_secret:, email:, password:)
+        client(environment:, app_id:, app_secret:).signup(email:, password:)
+      end
+
+      def login_with_client(environment:, app_id:, app_secret:, email:, password:)
+        client(environment:, app_id:, app_secret:).login(email:, password:)
+      end
+
+      def me_with_client(environment:, app_id:, app_secret:, access_token:)
+        client(environment:, app_id:, app_secret:).me(access_token:)
+      end
+
+      def logout_with_client(environment:, app_id:, app_secret:, access_token:)
+        client(environment:, app_id:, app_secret:).logout(access_token:)
+      end
+
+      def remove_with_client(environment:, app_id:, app_secret:, access_token:)
+        client(environment:, app_id:, app_secret:).remove(access_token:)
+      end
+
+      private
+
+      def parse_json(payload)
+        return payload unless payload.is_a?(String)
+
+        JSON.parse(payload, symbolize_names: true)
+      end
+
+      def normalize_error(error)
+        payload = parse_json(error.message)
+        error_hash = payload[:error] || payload
+        message = error_hash[:message] || error.message
+        error_code = error_hash[:error_code]
+        Error.new(message, error_code: error_code, payload: payload)
+      rescue JSON::ParserError, NoMethodError, TypeError
+        Error.new(error.message)
+      end
+    end
+  end
+end

data/sig/auth.rbs

@@ -0,0 +1,37 @@
+module Auth
+  VERSION: String
+end
+
+module SmbCloud
+  module Auth
+    class Error < StandardError
+      attr_reader error_code: Integer?
+      attr_reader payload: untyped
+    end
+
+    module Environment
+      DEV: String
+      PRODUCTION: String
+    end
+
+    class Client
+      attr_reader environment: String
+      attr_reader app_id: String
+      attr_reader app_secret: String
+
+      def initialize: (environment: String, app_id: String, app_secret: String) -> void
+      def signup: (email: String, password: String) -> Hash[Symbol, untyped]
+      def login: (email: String, password: String) -> Hash[Symbol, untyped]
+      def me: (access_token: String) -> Hash[Symbol, untyped]
+      def logout: (access_token: String) -> bool
+      def remove: (access_token: String) -> bool
+    end
+
+    def self.client: (environment: String, app_id: String, app_secret: String) -> Client
+    def self.signup_with_client: (environment: String, app_id: String, app_secret: String, email: String, password: String) -> Hash[Symbol, untyped]
+    def self.login_with_client: (environment: String, app_id: String, app_secret: String, email: String, password: String) -> Hash[Symbol, untyped]
+    def self.me_with_client: (environment: String, app_id: String, app_secret: String, access_token: String) -> Hash[Symbol, untyped]
+    def self.logout_with_client: (environment: String, app_id: String, app_secret: String, access_token: String) -> bool
+    def self.remove_with_client: (environment: String, app_id: String, app_secret: String, access_token: String) -> bool
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: smbcloud-auth
+version: !ruby/object:Gem::Version
+  version: 0.3.33
+platform: ruby
+authors:
+- Seto Elkahfi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.91
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.91
+description: Ruby bindings for smbCloud Auth, powered by the shared Rust SDK and a
+  native Magnus extension.
+email:
+- hej@setoelkahfi.se
+executables: []
+extensions:
+- ext/auth/extconf.rb
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- README.md
+- Rakefile
+- ext/.keep
+- ext/auth/Cargo.toml
+- ext/auth/extconf.rb
+- ext/auth/src/lib.rs
+- lib/auth.rb
+- lib/auth/version.rb
+- sig/auth.rbs
+homepage: https://github.com/smbcloudXYZ/smbcloud-cli/tree/main/sdk/gems/auth
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/smbcloudXYZ/smbcloud-cli/tree/main/sdk/gems/auth
+  source_code_uri: https://github.com/smbcloudXYZ/smbcloud-cli/tree/main/sdk/gems/auth
+  changelog_uri: https://github.com/smbcloudXYZ/smbcloud-cli/tree/main/sdk/gems/auth/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruby bindings for the smbCloud Auth SDK.
+test_files: []