jac-scale 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

jac_scale/abstractions/config/app_config.jac

@@ -7,7 +7,8 @@ class AppConfig {
         file_name: str = 'none',
         build: bool = False,
         app_name: (str | None) = None,
-        testing: bool = False;
+        testing: bool = False,
+        experimental: bool = False;
 
     def init(
         self: AppConfig,
@@ -15,13 +16,15 @@ class AppConfig {
         file_name: str = 'none',
         build: bool = False,
         app_name: (str | None) = None,
-        testing: bool = False
+        testing: bool = False,
+        experimental: bool = False
     ) -> None {
         self.code_folder = code_folder;
         self.file_name = file_name;
         self.build = build;
         self.app_name = app_name;
         self.testing = testing;
+        self.experimental = experimental;
     }
 
     def get_code_path(self: AppConfig) -> Path {

jac_scale/config_loader.jac

@@ -12,7 +12,7 @@ import os;
 
 """Scale-specific configuration loader.
 
-Provides access to jwt, sso, database, kubernetes, and server configuration
+Provides access to jwt, sso, database, kubernetes, server and webhook configuration
 from the [plugins.scale] section of jac.toml.
 """
 class JacScaleConfig(PluginConfigBase) {
@@ -23,6 +23,7 @@ class JacScaleConfig(PluginConfigBase) {
     def get_database_config(self: JacScaleConfig) -> dict[str, Any];
     def get_kubernetes_config(self: JacScaleConfig) -> dict[str, Any];
     def get_server_config(self: JacScaleConfig) -> dict[str, Any];
+    def get_webhook_config(self: JacScaleConfig) -> dict[str, Any];
 }
 
 glob _scale_config_instance: JacScaleConfig | None = None;

jac_scale/context.jac

@@ -1,8 +1,9 @@
+import from contextvars { ContextVar }
 import from dataclasses { MISSING }
 import from typing { Any }
 import from uuid { UUID }
 import from jaclang.pycore.constant { Constants as Con }
-import from jaclang.runtimelib.context { ExecutionContext }
+import from jaclang.runtimelib.context { ExecutionContext, CallState }
 
 """Jac Scale Execution Context with custom memory backend.
 

jac_scale/factories/storage_factory.jac

@@ -0,0 +1,75 @@
+"""Factory for creating storage instances."""
+import from typing { Any }
+import os;
+import from jaclang.runtimelib.storage { Storage }
+import from jaclang.project.config { get_config }
+
+enum StorageType {
+    LOCAL = "local"
+    # Future: S3, GCS, AZURE - add when implemented
+}
+
+"""Factory for creating storage instances.
+
+Configuration priority: jac.toml > environment variable > default
+
+In jac.toml:
+    [storage]
+    type = "local"  # or "s3", "gcs", "azure"
+    base_path = "/data/storage"
+    create_dirs = true
+
+Environment variables:
+    JAC_STORAGE_TYPE: Storage type (local, s3, gcs, azure)
+    JAC_STORAGE_PATH: Base directory for local storage
+    JAC_STORAGE_CREATE_DIRS: Whether to auto-create directories
+"""
+class StorageFactory {
+    static def create(
+        storage_type: (StorageType | str), config: (dict[str, Any] | None) = None
+    ) -> Storage {
+        # Convert string to enum if needed
+        if isinstance(storage_type, str) {
+            storage_type = StorageType(storage_type);
+        }
+
+        if storage_type == StorageType.LOCAL {
+            import from jaclang.runtimelib.storage { LocalStorage }
+            cfg = config or {};
+            return LocalStorage(
+                base_path=cfg.get("base_path", "./storage"),
+                create_dirs=cfg.get("create_dirs", True)
+            );
+        }
+        raise ValueError(f"Unsupported storage type: {storage_type}") ;
+    }
+
+    static def get_default(
+        base_path: str = "./storage", create_dirs: bool = True
+    ) -> Storage {
+        # Get config from jac.toml if available
+        jac_config = get_config();
+
+        # Config priority: jac.toml > env var > parameter
+        if jac_config and jac_config.storage {
+            storage_type = StorageType(jac_config.storage.storage_type);
+            base_path = jac_config.storage.base_path;
+            create_dirs = jac_config.storage.create_dirs;
+        } elif os.environ.get("JAC_STORAGE_TYPE") or os.environ.get("JAC_STORAGE_PATH") {
+            storage_type_str = os.environ.get(
+                "JAC_STORAGE_TYPE", StorageType.LOCAL.value
+            );
+            storage_type = StorageType(storage_type_str);
+            base_path = os.environ.get("JAC_STORAGE_PATH", base_path);
+            create_dirs_str = os.environ.get(
+                "JAC_STORAGE_CREATE_DIRS", str(create_dirs)
+            );
+            create_dirs = create_dirs_str.lower() == "true";
+        } else {
+            storage_type = StorageType.LOCAL;
+        }
+
+        storage_config = {"base_path": base_path, "create_dirs": create_dirs};
+        return StorageFactory.create(storage_type, storage_config);
+    }
+}

jac_scale/google_sso_provider.jac

@@ -0,0 +1,85 @@
+"""Google SSO Provider implementation for jac-scale.
+
+This module implements the SSOProvider interface for Google OAuth authentication.
+"""
+
+import from fastapi { Request, Response }
+import from fastapi_sso.sso.google { GoogleSSO }
+import from jac_scale.sso_provider { SSOProvider, SSOUserInfo }
+
+"""Google OAuth SSO Provider.
+
+This class wraps the fastapi_sso GoogleSSO implementation to conform to
+our SSOProvider interface, enabling consistent handling across all SSO vendors.
+"""
+obj GoogleSSOProvider(SSOProvider) {
+    has client_id: str,
+        client_secret: str,
+        redirect_uri: str,
+        allow_insecure_http: bool = True,
+        _google_sso: (GoogleSSO | None) = None;
+
+    """Initialize the Google SSO provider."""
+    def postinit -> None {
+        self._google_sso = GoogleSSO(
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            redirect_uri=self.redirect_uri,
+            allow_insecure_http=self.allow_insecure_http
+        );
+    }
+
+    """Initiate Google OAuth authentication flow.
+
+    Args:
+        operation: The operation type ('login' or 'register')
+
+    Returns:
+        RedirectResponse to Google's OAuth authorization page
+    """
+    async def initiate_auth(operation: str) -> Response {
+        if not self._google_sso {
+            raise RuntimeError("GoogleSSO not initialized") ;
+        }
+
+        with self._google_sso {
+            return await self._google_sso.get_login_redirect();
+        }
+    }
+
+    """Handle the OAuth callback from Google.
+
+    Args:
+        request: The FastAPI request object containing OAuth callback data
+
+    Returns:
+        SSOUserInfo: Standardized user information from Google
+
+    Raises:
+        Exception: If authentication fails or user info cannot be retrieved
+    """
+    async def handle_callback(request: Request) -> SSOUserInfo {
+        if not self._google_sso {
+            raise RuntimeError("GoogleSSO not initialized") ;
+        }
+
+        with self._google_sso {
+            user_info = await self._google_sso.verify_and_process(request);
+            return SSOUserInfo(
+                email=user_info.email,
+                external_id=user_info.id,
+                platform=self.get_platform_name(),
+                display_name=user_info?.display_name
+            );
+        }
+    }
+
+    """Get the platform identifier.
+
+    Returns:
+        str: 'google'
+    """
+    def get_platform_name -> str {
+        return "google";
+    }
+}

jac_scale/impl/config_loader.impl.jac

@@ -18,7 +18,11 @@ impl JacScaleConfig.get_plugin_name(self: JacScaleConfig) -> str {
 """Get default configuration structure for scale."""
 impl JacScaleConfig.get_default_config(self: JacScaleConfig) -> dict[str, Any] {
     return {
-        'jwt': {'secret': 'supersecretkey', 'algorithm': 'HS256', 'exp_delta_days': 7},
+        'jwt': {
+            'secret': 'supersecretkey_for_testing_only!',
+            'algorithm': 'HS256',
+            'exp_delta_days': 7
+        },
         'sso': {
             'host': 'http://localhost:8000/sso',
             'google': {'client_id': '', 'client_secret': ''}
@@ -50,7 +54,13 @@ impl JacScaleConfig.get_default_config(self: JacScaleConfig) -> dict[str, Any] {
             'liveness_period': 20,
             'liveness_failure_threshold': 80
         },
-        'server': {'port': 8000, 'host': '0.0.0.0'}
+        'server': {'port': 8000, 'host': '0.0.0.0'},
+        'webhook': {
+            'secret': 'webhook-secret-key',
+            'signature_header': 'X-Webhook-Signature',
+            'verify_signature': True,
+            'api_key_expiry_days': 365
+        }
     };
 }
 
@@ -59,7 +69,7 @@ impl JacScaleConfig.get_jwt_config(self: JacScaleConfig) -> dict[str, Any] {
     config = self.load();
     jwt_config = config.get('jwt', {});
     return {
-        'secret': jwt_config.get('secret', 'supersecretkey'),
+        'secret': jwt_config.get('secret', 'supersecretkey_for_testing_only!'),
         'algorithm': jwt_config.get('algorithm', 'HS256'),
         'exp_delta_days': int(jwt_config.get('exp_delta_days', 7))
     };
@@ -115,6 +125,21 @@ impl JacScaleConfig.get_server_config(self: JacScaleConfig) -> dict[str, Any] {
     };
 }
 
+"""Get webhook configuration from jac.toml."""
+impl JacScaleConfig.get_webhook_config(self: JacScaleConfig) -> dict[str, Any] {
+    config = self.load();
+    webhook_config = config.get('webhook', {});
+    return {
+        'secret': os.environ.get('WEBHOOK_SECRET')
+        or webhook_config.get('secret', 'webhook-secret-key'),
+        'signature_header': webhook_config.get(
+            'signature_header', 'X-Webhook-Signature'
+        ),
+        'verify_signature': webhook_config.get('verify_signature', True),
+        'api_key_expiry_days': int(webhook_config.get('api_key_expiry_days', 365))
+    };
+}
+
 """Get or create the global JacScaleConfig instance."""
 impl get_scale_config(project_dir: Path | None = None) -> JacScaleConfig {
     global _scale_config_instance;

jac_scale/impl/context.impl.jac

@@ -21,4 +21,5 @@ impl JScaleExecutionContext.init(self: JScaleExecutionContext) -> None {
     # Default user_root and entry_node to system_root
     self.user_root = self.system_root;
     self.entry_node = self.system_root;
+    self.call_state: ContextVar[CallState] = ContextVar('call_state');
 }