ngapakin 1.0.0__py3-none-any.whl

framework/__init__.py

@@ -0,0 +1,5 @@
+"""
+Larapak Framework - MVC Web Framework for NgapakIn Language.
+"""
+
+__version__ = "1.0.0"

framework/auth.py

@@ -0,0 +1,75 @@
+# Authentication System for Larapak
+
+from framework.database import db_manager
+
+class Auth:
+    def __init__(self, vm=None):
+        self.vm = vm
+
+    @property
+    def sesi(self):
+        if self.vm and "sesi" in self.vm.globals:
+            return self.vm.globals["sesi"]
+        return None
+
+    def user(self):
+        ses = self.sesi
+        if not ses:
+            return None
+        user_id = ses.get("auth_user_id")
+        if not user_id:
+            return None
+        
+        if self.vm and "User" in self.vm.globals:
+            User = self.vm.globals["User"]
+            # Call User.golek(user_id)
+            # golek is a classmethod on Model, which wraps it.
+            # In Python, we can call it using __func__ since Model.golek is a classmethod
+            from framework.model import Model
+            return Model.golek.__func__(User, user_id)
+        return None
+
+    def cek(self):
+        return self.user() is not None
+
+    def check(self):
+        return self.cek()
+
+    def mlebu(self, email, password):
+        """Login user with email and password."""
+        if self.vm and "User" in self.vm.globals:
+            User = self.vm.globals["User"]
+            from framework.model import Model
+            # Query user using ModelQueryBuilder
+            # We will make sure Model.nek works and returns a user.
+            # Or we can query directly via SQL for safety inside auth:
+            table = Model.get_table_name(User)
+            row = db_manager.execute(f"SELECT * FROM {table} WHERE email = ?", [email]).fetchone()
+            if row:
+                user_dict = dict(row)
+                if user_dict.get("password") == password:
+                    ses = self.sesi
+                    if ses:
+                        ses.set("auth_user_id", user_dict.get("id"))
+                    
+                    # Instantiate user object
+                    from ngapak.vm import NgapakInstance
+                    instance = User() if hasattr(User, 'attributes') else User.__new__(User)
+                    if isinstance(instance, NgapakInstance):
+                        instance.fields.update(user_dict)
+                    else:
+                        instance.__dict__.update(user_dict)
+                    return True
+        return False
+
+    def login(self, email, password):
+        return self.mlebu(email, password)
+
+    def metu(self):
+        """Logout current user."""
+        ses = self.sesi
+        if ses:
+            ses.forget("auth_user_id")
+
+    def logout(self):
+        self.metu()

framework/cache.py

@@ -0,0 +1,72 @@
+# Cache Manager for Larapak
+
+import time
+import json
+from framework.database import db_manager
+
+class Cache:
+    def __init__(self):
+        self._ensure_table()
+
+    def _ensure_table(self):
+        db_manager.execute_write(
+            "CREATE TABLE IF NOT EXISTS cache (key VARCHAR(255) PRIMARY KEY, value TEXT, expiration INTEGER)"
+        )
+
+    def pasang(self, key, value, seconds=None):
+        expiration = None
+        if seconds is not None:
+            expiration = int(time.time() + seconds)
+        
+        serialized = json.dumps(value)
+        db_manager.execute_write(
+            "INSERT OR REPLACE INTO cache (key, value, expiration) VALUES (?, ?, ?)",
+            [key, serialized, expiration]
+        )
+        return True
+
+    def set(self, key, value, seconds=None):
+        return self.pasang(key, value, seconds)
+
+    def entuk(self, key, default=None):
+        row = db_manager.execute("SELECT value, expiration FROM cache WHERE key = ?", [key]).fetchone()
+        if not row:
+            return default
+            
+        expiration = row["expiration"]
+        if expiration is not None and expiration <= time.time():
+            # Expired, remove it
+            self.lalekna(key)
+            return default
+            
+        try:
+            return json.loads(row["value"])
+        except Exception:
+            return default
+
+    def get(self, key, default=None):
+        return self.entuk(key, default)
+
+    def lalekna(self, key):
+        db_manager.execute_write("DELETE FROM cache WHERE key = ?", [key])
+        return True
+
+    def forget(self, key):
+        return self.lalekna(key)
+
+    def remove(self, key):
+        return self.lalekna(key)
+
+    def resiki(self):
+        db_manager.execute_write("DELETE FROM cache")
+        return True
+
+    def clear(self):
+        return self.resiki()
+
+    def nduwe(self, key):
+        val = self.entuk(key, None)
+        return val is not None
+
+    def has(self, key):
+        return self.nduwe(key)

framework/container.py

@@ -0,0 +1,42 @@
+# Service Container for Larapak Web Framework
+
+class Container:
+    def __init__(self):
+        self.bindings = {}
+        self.instances = {}
+        self.vm = None  # Injected by VM
+
+    def bind(self, name, factory):
+        """Bind a dependency resolver function to a name."""
+        self.bindings[name] = factory
+
+    def singleton(self, name, factory):
+        """Bind a singleton dependency resolver."""
+        def singleton_factory():
+            if name not in self.instances:
+                if self.vm and callable(factory):
+                    # If it's a VM function, invoke it
+                    self.instances[name] = self.vm.execute_callable(factory, [])
+                else:
+                    self.instances[name] = factory()
+            return self.instances[name]
+        self.bindings[name] = singleton_factory
+
+    def make(self, name):
+        """Resolve dependency by name."""
+        if name in self.instances:
+            return self.instances[name]
+            
+        if name in self.bindings:
+            factory = self.bindings[name]
+            # Check if it is a VM function
+            if self.vm and hasattr(factory, 'chunk'):
+                res = self.vm.execute_callable(factory, [])
+                return res
+            elif callable(factory):
+                res = factory()
+                return res
+            else:
+                return factory
+                
+        raise KeyError(f"Dependency '{name}' tidak ditemukan di Service Container.")

framework/controller.py

@@ -0,0 +1,51 @@
+# Controller resolution and loader for Larapak
+
+import os
+from ngapak import Lexer, Parser, Compiler, NgapakError
+
+class ControllerLoader:
+    def __init__(self, controllers_path, vm):
+        self.controllers_path = controllers_path
+        self.vm = vm
+        self.loaded_controllers = {}
+
+    def call_action(self, action_str, req, res):
+        """Invoke controller action method (e.g. 'HomeController@index') on VM."""
+        parts = action_str.split("@")
+        if len(parts) < 2:
+            raise ValueError(f"Format aksi controller tidak valid: '{action_str}'")
+            
+        controller_name = parts[0]
+        action_name = parts[1]
+
+        # Load and run controller file once to register its functions in VM globals
+        if controller_name not in self.loaded_controllers:
+            filepath = os.path.join(self.controllers_path, f"{controller_name}.ngpk")
+            if not os.path.exists(filepath):
+                raise FileNotFoundError(f"Controller '{controller_name}' tidak ditemukan di '{filepath}'")
+                
+            with open(filepath, "r", encoding="utf-8") as f:
+                source = f.read()
+                
+            lexer = Lexer(source, filepath)
+            tokens = lexer.tokenize()
+            parser = Parser(tokens, filepath)
+            ast = parser.parse()
+            
+            compiler = Compiler(filepath)
+            main_fn = compiler.compile(ast)
+            
+            # Execute the controller file main scope to define functions
+            self.vm.execute_callable(main_fn, [])
+            self.loaded_controllers[controller_name] = True
+
+        # Retrieve action function from VM globals
+        if action_name not in self.vm.globals:
+            raise AttributeError(f"Aksi '{action_name}' tidak ditemukan di Controller '{controller_name}'.")
+            
+        action_fn = self.vm.globals[action_name]
+
+        # Call the controller function on VM: action(req, res)
+        # Returns the Response object modified or returned by the function
+        result_response = self.vm.execute_callable(action_fn, [req, res])
+        return result_response

framework/database.py

@@ -0,0 +1,58 @@
+# Database Connection & Transaction Manager for Larapak
+
+import os
+import sqlite3
+
+class DatabaseConnection:
+    def __init__(self, db_path="database.sqlite"):
+        self.db_path = db_path
+        self._conn = None
+        self.query_log = []
+        self.log_queries = True
+
+    def get_connection(self):
+        if self._conn is None:
+            # Ensure folder exists
+            db_dir = os.path.dirname(self.db_path)
+            if db_dir and not os.path.exists(db_dir):
+                os.makedirs(db_dir, exist_ok=True)
+            self._conn = sqlite3.connect(self.db_path, check_same_thread=False)
+            self._conn.row_factory = sqlite3.Row
+        return self._conn
+
+    def execute(self, sql, params=None):
+        params = params or []
+        if self.log_queries:
+            print(f"[SQL] {sql} | Params: {params}")
+            self.query_log.append((sql, params))
+        
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        cursor.execute(sql, params)
+        return cursor
+
+    def execute_write(self, sql, params=None):
+        params = params or []
+        cursor = self.execute(sql, params)
+        conn = self.get_connection()
+        conn.commit()
+        return cursor.lastrowid
+
+    def begin_transaction(self):
+        self.execute("BEGIN")
+
+    def commit(self):
+        self.execute("COMMIT")
+
+    def rollback(self):
+        self.execute("ROLLBACK")
+
+    def close(self):
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+from .env import env
+
+# Global db connection
+db_manager = DatabaseConnection(env("DB_DATABASE", "database.sqlite"))

framework/env.py

@@ -0,0 +1,44 @@
+# Environment Configuration Loader for Larapak (.env)
+
+import os
+
+_ENV_LOADED = False
+
+def load_env(env_file=".env"):
+    """Loads key-value pairs from .env file into os.environ."""
+    global _ENV_LOADED
+    if not os.path.exists(env_file):
+        return
+        
+    with open(env_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            # Skip empty lines and comments
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                key, val = line.split("=", 1)
+                key = key.strip()
+                val = val.strip()
+                # Strip wrapping single or double quotes
+                if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+                    val = val[1:-1]
+                # Only set if not already overridden by system environment
+                if key not in os.environ:
+                    os.environ[key] = val
+                    
+    _ENV_LOADED = True
+
+def env(key, default=None):
+    """Retrieves an environment variable with optional fallback default."""
+    if not _ENV_LOADED:
+        load_env()
+    val = os.environ.get(key, default)
+    # Type conversions for standard boolean and null strings
+    if val == "bener" or val == "true" or val == "True":
+        return True
+    if val == "salah" or val == "false" or val == "False":
+        return False
+    if val == "kosong" or val == "null" or val == "None":
+        return None
+    return val

framework/event.py

@@ -0,0 +1,30 @@
+# Event Dispatcher for Larapak
+
+class Event:
+    def __init__(self, vm=None):
+        self.vm = vm
+        self.listeners = {}
+
+    def rungokna(self, event_name, listener):
+        if event_name not in self.listeners:
+            self.listeners[event_name] = []
+        self.listeners[event_name].append(listener)
+
+    def listen(self, event_name, listener):
+        self.rungokna(event_name, listener)
+
+    def kirim(self, event_name, data=None):
+        if event_name not in self.listeners:
+            return
+            
+        for listener in self.listeners[event_name]:
+            # Call the listener
+            if hasattr(listener, 'chunk'):
+                # Ngapak VM Function
+                if self.vm:
+                    self.vm.execute_callable(listener, [data] if data is not None else [])
+            elif callable(listener):
+                listener(data) if data is not None else listener()
+
+    def dispatch(self, event_name, data=None):
+        self.kirim(event_name, data)

framework/middleware.py

@@ -0,0 +1,62 @@
+# Middleware pipeline execution for Larapak
+
+import os
+from ngapak import Lexer, Parser, Compiler, NgapakError
+
+class MiddlewarePipeline:
+    def __init__(self, middleware_path, vm):
+        self.middleware_path = middleware_path
+        self.vm = vm
+        self.middleware_map = {
+            "auth": "AuthMiddleware"  # Map shorthand aliases
+        }
+        self.loaded_middleware = {}
+
+    def execute_chain(self, middleware_names, req, res, destination):
+        """Execute middleware list sequentially, ending at destination controller call."""
+        idx = 0
+        
+        def next_step(current_req, current_res):
+            nonlocal idx
+            if idx < len(middleware_names):
+                name = middleware_names[idx]
+                idx += 1
+                return self.run_middleware(name, current_req, current_res, next_step)
+            else:
+                return destination(current_req, current_res)
+                
+        return next_step(req, res)
+
+    def run_middleware(self, name, req, res, next_cb):
+        class_name = self.middleware_map.get(name, name)
+        
+        # Load and run middleware file once to register its functions
+        if class_name not in self.loaded_middleware:
+            filepath = os.path.join(self.middleware_path, f"{class_name}.ngpk")
+            if not os.path.exists(filepath):
+                raise FileNotFoundError(f"Middleware '{class_name}' tidak ditemukan di '{filepath}'")
+                
+            with open(filepath, "r", encoding="utf-8") as f:
+                source = f.read()
+                
+            lexer = Lexer(source, filepath)
+            tokens = lexer.tokenize()
+            parser = Parser(tokens, filepath)
+            ast = parser.parse()
+            
+            compiler = Compiler(filepath)
+            main_fn = compiler.compile(ast)
+            
+            self.vm.execute_callable(main_fn, [])
+            self.loaded_middleware[class_name] = True
+
+        # Middlewares define a global function called 'tangani(req, res, lanjut)'
+        if "tangani" not in self.vm.globals:
+            return next_cb(req, res)
+            
+        tangani_fn = self.vm.globals["tangani"]
+        
+        # Run middleware tangani(req, res, next_cb) on VM.
+        # next_cb is passed directly as Python callback.
+        res_obj = self.vm.execute_callable(tangani_fn, [req, res, next_cb])
+        return res_obj

framework/model.py

@@ -0,0 +1,232 @@
+# Base ORM Model for Larapak (Eloquent-like)
+
+from .database import db_manager
+from .query_builder import QueryBuilder
+from ngapak.vm import NgapakClass, NgapakInstance
+
+class Model:
+    active_vm = None
+    tabel = None
+    fillable = []
+
+    @classmethod
+    def get_table_name(cls, class_obj):
+        if isinstance(class_obj, NgapakClass):
+            return class_obj.attributes.get("tabel", f"{class_obj.name.lower()}s")
+        return getattr(class_obj, "tabel", f"{class_obj.__name__.lower()}s")
+
+    @classmethod
+    def get_fillable(cls, class_obj):
+        if isinstance(class_obj, NgapakClass):
+            return class_obj.attributes.get("fillable", [])
+        return getattr(class_obj, "fillable", [])
+
+    @classmethod
+    def kabeh(cls):
+        # cls is the class object (e.g. NgapakClass 'User' or Model subclass)
+        table = Model.get_table_name(cls)
+        rows = QueryBuilder(table).kabeh()
+        
+        instances = []
+        for row in rows:
+            instance = cls() if isinstance(cls, NgapakClass) else cls.__new__(cls)
+            if isinstance(instance, NgapakInstance):
+                instance.fields.update(row)
+            else:
+                instance.__dict__.update(row)
+            instances.append(instance)
+        return instances
+
+    @classmethod
+    def golek(cls, record_id):
+        table = Model.get_table_name(cls)
+        row = QueryBuilder(table).nek("id", "==", record_id).golek()
+        if not row:
+            return None
+            
+        instance = cls() if isinstance(cls, NgapakClass) else cls.__new__(cls)
+        if isinstance(instance, NgapakInstance):
+            instance.fields.update(row)
+        else:
+            instance.__dict__.update(row)
+        return instance
+
+    @classmethod
+    def gawe(cls, data):
+        table = Model.get_table_name(cls)
+        fillable = Model.get_fillable(cls)
+        
+        # Filter fields based on fillable
+        filtered_data = {}
+        if fillable:
+            for k, v in data.items():
+                if k in fillable:
+                    filtered_data[k] = v
+        else:
+            filtered_data = data
+            
+        record_id = QueryBuilder(table).tambah(filtered_data)
+        
+        # Reload instance from DB to get autogenerated fields/defaults
+        return Model.golek.__func__(cls, record_id)
+
+    # Instance Methods
+    def simpen(self):
+        # self is NgapakInstance or Model subclass
+        cls = self.ngapak_class if isinstance(self, NgapakInstance) else self.__class__
+        table = Model.get_table_name(cls)
+        
+        fields = self.fields if isinstance(self, NgapakInstance) else self.__dict__
+        
+        if "id" in fields and fields["id"] is not None:
+            # Update
+            QueryBuilder(table).nek("id", "==", fields["id"]).anyari(fields)
+        else:
+            # Insert
+            record_id = QueryBuilder(table).tambah(fields)
+            fields["id"] = record_id
+        return self
+
+    def busak(self):
+        cls = self.ngapak_class if isinstance(self, NgapakInstance) else self.__class__
+        table = Model.get_table_name(cls)
+        fields = self.fields if isinstance(self, NgapakInstance) else self.__dict__
+        
+        if "id" in fields and fields["id"] is not None:
+            QueryBuilder(table).nek("id", "==", fields["id"]).busak()
+            fields["id"] = None
+        return self
+
+    # Relationship Methods
+    def hasOne(self, related_class_name, foreign_key=None, local_key="id"):
+        if not Model.active_vm:
+            return None
+            
+        related_class = Model.active_vm.globals.get(related_class_name)
+        if not related_class:
+            raise ValueError(f"Model '{related_class_name}' tidak ditemukan di VM globals.")
+            
+        related_table = Model.get_table_name(related_class)
+        
+        # Resolve foreign key
+        cls = self.ngapak_class if isinstance(self, NgapakInstance) else self.__class__
+        if foreign_key is None:
+            foreign_key = f"{cls.name.lower()}_id"
+            
+        fields = self.fields if isinstance(self, NgapakInstance) else self.__dict__
+        local_val = fields.get(local_key)
+        
+        row = QueryBuilder(related_table).nek(foreign_key, "==", local_val).golek()
+        if not row:
+            return None
+            
+        instance = related_class() if isinstance(related_class, NgapakClass) else related_class.__new__(related_class)
+        if isinstance(instance, NgapakInstance):
+            instance.fields.update(row)
+        else:
+            instance.__dict__.update(row)
+        return instance
+
+    def hasMany(self, related_class_name, foreign_key=None, local_key="id"):
+        if not Model.active_vm:
+            return []
+            
+        related_class = Model.active_vm.globals.get(related_class_name)
+        if not related_class:
+            raise ValueError(f"Model '{related_class_name}' tidak ditemukan di VM globals.")
+            
+        related_table = Model.get_table_name(related_class)
+        
+        # Resolve foreign key
+        cls = self.ngapak_class if isinstance(self, NgapakInstance) else self.__class__
+        if foreign_key is None:
+            foreign_key = f"{cls.name.lower()}_id"
+            
+        fields = self.fields if isinstance(self, NgapakInstance) else self.__dict__
+        local_val = fields.get(local_key)
+        
+        rows = QueryBuilder(related_table).nek(foreign_key, "==", local_val).kabeh()
+        
+        instances = []
+        for row in rows:
+            instance = related_class() if isinstance(related_class, NgapakClass) else related_class.__new__(related_class)
+            if isinstance(instance, NgapakInstance):
+                instance.fields.update(row)
+            else:
+                instance.__dict__.update(row)
+            instances.append(instance)
+        return instances
+
+    def belongsTo(self, related_class_name, foreign_key=None, owner_key="id"):
+        if not Model.active_vm:
+            return None
+            
+        related_class = Model.active_vm.globals.get(related_class_name)
+        if not related_class:
+            raise ValueError(f"Model '{related_class_name}' tidak ditemukan di VM globals.")
+            
+        related_table = Model.get_table_name(related_class)
+        
+        # Resolve foreign key
+        if foreign_key is None:
+            foreign_key = f"{related_class_name.lower()}_id"
+            
+        fields = self.fields if isinstance(self, NgapakInstance) else self.__dict__
+        foreign_val = fields.get(foreign_key)
+        
+        row = QueryBuilder(related_table).nek(owner_key, "==", foreign_val).golek()
+        if not row:
+            return None
+            
+        instance = related_class() if isinstance(related_class, NgapakClass) else related_class.__new__(related_class)
+        if isinstance(instance, NgapakInstance):
+            instance.fields.update(row)
+        else:
+            instance.__dict__.update(row)
+        return instance
+
+    @classmethod
+    def nek(cls, kolom, op, nilai=None):
+        table = Model.get_table_name(cls)
+        qb = ModelQueryBuilder(cls, table)
+        return qb.nek(kolom, op, nilai)
+
+    @classmethod
+    def neng(cls, kolom, op, nilai=None):
+        return cls.nek(kolom, op, nilai)
+
+
+class ModelQueryBuilder(QueryBuilder):
+    def __init__(self, cls, table):
+        super().__init__(table)
+        self.cls = cls
+
+    def siji(self):
+        row = self.golek()
+        if not row:
+            return None
+        instance = self.cls() if isinstance(self.cls, NgapakClass) else self.cls.__new__(self.cls)
+        if isinstance(instance, NgapakInstance):
+            instance.fields.update(row)
+        else:
+            instance.__dict__.update(row)
+        return instance
+
+    def first(self):
+        return self.siji()
+
+    def kabeh(self):
+        rows = super().kabeh()
+        instances = []
+        for row in rows:
+            instance = self.cls() if isinstance(self.cls, NgapakClass) else self.cls.__new__(self.cls)
+            if isinstance(instance, NgapakInstance):
+                instance.fields.update(row)
+            else:
+                instance.__dict__.update(row)
+            instances.append(instance)
+        return instances
+
+    def all(self):
+        return self.kabeh()
+