matrx-orm 1.0.4__py3-none-any.whl

matrx_orm/__init__.py

@@ -0,0 +1,16 @@
+from .core.config import DatabaseProjectConfig, register_database, get_database_config, get_connection_string, \
+    get_manager_config, get_code_config, get_all_database_project_names, get_database_alias, get_all_database_projects_redacted
+
+from .core.extended import BaseManager, BaseDTO
+from .core.base import Model
+from .core.registry import model_registry
+from .core.fields import (CharField, EnumField, DateField, TextField, IntegerField, FloatField, BooleanField,
+                          DateTimeField, UUIDField, JSONField, DecimalField, BigIntegerField, SmallIntegerField,
+                          JSONBField, UUIDArrayField, JSONBArrayField, ForeignKey)
+
+__all__ = ["DatabaseProjectConfig", "register_database", "get_database_config", "get_connection_string",
+           "get_manager_config", "get_code_config", "get_all_database_project_names", "get_default_code_config",
+           "BaseManager", "BaseDTO", "Model", "model_registry", "CharField", "EnumField", "DateField", "TextField",
+           "IntegerField", "FloatField", "BooleanField", "DateTimeField", "UUIDField", "JSONField", "DecimalField",
+           "BigIntegerField", "SmallIntegerField", "JSONBField", "UUIDArrayField", "JSONBArrayField", "ForeignKey", "get_database_alias", 
+           "get_all_database_projects_redacted"]

matrx_orm/adapters/base_adapter.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Union
+from types import TracebackType
+from typing import Type, Optional
+
+
+class BaseAdapter(ABC):
+    @abstractmethod
+    async def execute_query(self, query: Dict[str, Any]) -> List[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    async def fetch(self, query: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    async def fetch_by_id(self, model: Any, record_id: Union[str, int]) -> Optional[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    async def count(self, query: Dict[str, Any]) -> int:
+        pass
+
+    @abstractmethod
+    async def exists(self, query: Dict[str, Any]) -> bool:
+        pass
+
+    @abstractmethod
+    async def insert(self, query: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def bulk_insert(self, query: Dict[str, Any]) -> List[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    async def update(self, query: Dict[str, Any], data: Dict[str, Any]) -> int:
+        pass
+
+    @abstractmethod
+    async def bulk_update(self, query: Dict[str, Any]) -> int:
+        pass
+
+    @abstractmethod
+    async def delete(self, query: Dict[str, Any]) -> int:
+        pass
+
+    @abstractmethod
+    async def raw_sql(self, sql: str, params: List[Any] = None) -> Union[List[Dict[str, Any]], int]:
+        pass
+
+    @abstractmethod
+    async def transaction(self):
+        pass
+
+    @abstractmethod
+    async def close(self):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ):
+        await self.close()

matrx_orm/adapters/postgresql.py

@@ -0,0 +1,171 @@
+from typing import Dict, Any, List, Union, Tuple
+import asyncpg
+from matrx_orm.adapters.base_adapter import BaseAdapter
+from matrx_orm import get_database_config
+from matrx_utils.conf import settings
+
+class PostgreSQLAdapter(BaseAdapter):
+    def __init__(self):
+
+        self.config = get_database_config()
+        self.connection = None
+        self.current_database = settings.DEFAULT_DB_PROJECT
+
+
+    async def _get_connection(self):
+        if self.connection is None or self.connection.is_closed():
+            self.connection = await asyncpg.connect(
+                host=self.config.host,
+                port=self.config.port,
+                database=self.config.name,
+                user=self.config.user,
+                password=self.config.password,
+            )
+        return self.connection
+
+    async def execute_query(self, query: Dict[str, Any]) -> List[Dict[str, Any]]:
+        sql, params = self._build_sql(query)
+        connection = await self._get_connection()
+        rows = await connection.fetch(sql, *params)
+        return [dict(row) for row in rows]
+
+    async def count(self, query: Dict[str, Any]) -> int:
+        sql, params = self._build_count_sql(query)
+        connection = await self._get_connection()
+        row = await connection.fetchrow(sql, *params)
+        return row["count"]
+
+    async def exists(self, query: Dict[str, Any]) -> bool:
+        sql, params = self._build_exists_sql(query)
+        connection = await self._get_connection()
+        row = await connection.fetchrow(sql, *params)
+        return row["exists"]
+
+    async def insert(self, query: Dict[str, Any]) -> Dict[str, Any]:
+        sql, params = self._build_insert_sql(query)
+        connection = await self._get_connection()
+        row = await connection.fetchrow(sql, *params)
+        return dict(row)
+
+    async def bulk_insert(self, query: Dict[str, Any]) -> List[Dict[str, Any]]:
+        sql, params = self._build_bulk_insert_sql(query)
+        connection = await self._get_connection()
+        await connection.executemany(sql, params)
+        return await connection.fetch(sql, *params)
+
+    async def update(self, query: Dict[str, Any], data: Dict[str, Any]) -> int:
+        sql, params = self._build_update_sql(query, data)
+        connection = await self._get_connection()
+        result = await connection.execute(sql, *params)
+        return result
+
+    async def bulk_update(self, query: Dict[str, Any]) -> int:
+        sql, params = self._build_bulk_update_sql(query)
+        connection = await self._get_connection()
+        result = await connection.executemany(sql, params)
+        return result
+
+    async def delete(self, query: Dict[str, Any]) -> int:
+        sql, params = self._build_delete_sql(query)
+        connection = await self._get_connection()
+        result = await connection.execute(sql, *params)
+        return result
+
+    async def raw_sql(self, sql: str, params: List[Any] = None) -> Union[List[Dict[str, Any]], int]:
+        connection = await self._get_connection()
+        if sql.strip().upper().startswith("SELECT"):
+            rows = await connection.fetch(sql, *params)
+            return [dict(row) for row in rows]
+        else:
+            return await connection.execute(sql, *params)
+
+    async def close(self):
+        if self.connection is not None and not self.connection.is_closed():
+            await self.connection.close()
+
+    async def transaction(self):
+        connection = await self._get_connection()
+        async with connection.transaction():
+            yield
+
+    async def savepoint(self, name: str):
+        connection = await self._get_connection()
+        await connection.execute(f"SAVEPOINT {name}")
+
+    async def rollback_to_savepoint(self, name: str):
+        connection = await self._get_connection()
+        await connection.execute(f"ROLLBACK TO SAVEPOINT {name}")
+
+    async def release_savepoint(self, name: str):
+        connection = await self._get_connection()
+        await connection.execute(f"RELEASE SAVEPOINT {name}")
+
+    def _build_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        # Generic SQL building logic for select statements
+        sql = f"SELECT * FROM {query['model'].__tablename__} WHERE "
+        filters = []
+        params = []
+        for field, value in query["filters"].items():
+            filters.append(f"{field} = ${len(params) + 1}")
+            params.append(value)
+        sql += " AND ".join(filters)
+        return sql, params
+
+    def _build_count_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        sql = f"SELECT COUNT(*) FROM {query['model'].__tablename__} WHERE "
+        filters = []
+        params = []
+        for field, value in query["filters"].items():
+            filters.append(f"{field} = ${len(params) + 1}")
+            params.append(value)
+        sql += " AND ".join(filters)
+        return sql, params
+
+    def _build_exists_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        sql = f"SELECT EXISTS(SELECT 1 FROM {query['model'].__tablename__} WHERE "
+        filters = []
+        params = []
+        for field, value in query["filters"].items():
+            filters.append(f"{field} = ${len(params) + 1}")
+            params.append(value)
+        sql += " AND ".join(filters) + ")"
+        return sql, params
+
+    def _build_insert_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        fields = ", ".join(query["data"].keys())
+        placeholders = ", ".join([f"${i + 1}" for i in range(len(query["data"]))])
+        sql = f"INSERT INTO {query['model'].__tablename__} ({fields}) VALUES ({placeholders}) RETURNING *"
+        params = list(query["data"].values())
+        return sql, params
+
+    def _build_bulk_insert_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        fields = ", ".join(query["data"][0].keys())
+        placeholders = ", ".join([f"${i + 1}" for i in range(len(query["data"][0]))])
+        sql = f"INSERT INTO {query['model'].__tablename__} ({fields}) VALUES ({placeholders})"
+        params = [tuple(row.values()) for row in query["data"]]
+        return sql, params
+
+    def _build_update_sql(self, query: Dict[str, Any], data: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        set_clause = ", ".join([f"{key} = ${i + 1}" for i, key in enumerate(data.keys())])
+        sql = f"UPDATE {query['model'].__tablename__} SET {set_clause} WHERE "
+        filters = []
+        params = list(data.values())
+        for field, value in query["filters"].items():
+            filters.append(f"{field} = ${len(params) + 1}")
+            params.append(value)
+        sql += " AND ".join(filters)
+        return sql, params
+
+    def _build_bulk_update_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        # Similar to update but for bulk updates
+        raise NotImplementedError("Bulk update logic to be implemented")
+
+    def _build_delete_sql(self, query: Dict[str, Any]) -> Tuple[str, List[Any]]:
+        sql = f"DELETE FROM {query['model'].__tablename__} WHERE "
+        filters = []
+        params = []
+        for field, value in query["filters"].items():
+            filters.append(f"{field} = ${len(params) + 1}")
+            params.append(value)
+        sql += " AND ".join(filters)
+        return sql, params

matrx_orm/client/__init__.py

@@ -0,0 +1 @@
+from .postgres_connection import get_postgres_connection

matrx_orm/client/postgres_connection.py

@@ -0,0 +1,144 @@
+import json
+import os
+from typing import Any, Dict, List
+
+from psycopg2 import pool
+from psycopg2.extras import RealDictCursor
+from matrx_utils import vcprint
+
+from matrx_orm.utils.sql_utils import sql_param_to_psycopg2
+from matrx_orm import get_database_config
+
+connection_pools = {}
+
+
+def init_connection_details(config_name):
+    global connection_pools
+
+    if config_name not in connection_pools:
+        config = get_database_config(config_name=config_name)
+        vcprint(f"\n[Matrx ORM] Using configuration for: {config_name}\n", color="green")
+
+        db_host = config.get("host")
+        db_port = config.get("port")
+        db_name = config.get("database_name")
+        db_user = config.get("user")
+        db_password = config.get("password")
+
+        if not all([db_host, db_port, db_name, db_user, db_password]):
+            raise ValueError(
+                f"Incomplete database configuration for '{config_name}'. " "Please check your environment variables or settings.")
+
+        connection_string = f"postgresql://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}"
+
+        vcprint(f"\n[Matrx ORM] Connection String:\n{connection_string}\n", color="green")
+
+        connection_pools[config_name] = pool.SimpleConnectionPool(1, 10, dsn=connection_string, sslmode="require")
+
+
+def get_postgres_connection(
+        database_project="this_will_cause_error_specify_the_database",
+):
+    init_connection_details(database_project)
+    conn = connection_pools[database_project].getconn()
+    return conn
+
+
+def execute_sql_query(query, params=None, database_project="this_will_cause_error_specify_the_database"):
+    """
+    Executes a SQL query and returns the results as a list of dictionaries.
+    """
+    conn = get_postgres_connection(database_project)
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            if params and isinstance(params, dict):
+                query, params = sql_param_to_psycopg2(query, params)
+            cur.execute(query, params)
+            return cur.fetchall()
+    finally:
+        connection_pools[database_project].putconn(conn)
+
+
+def execute_sql_file(filename, params=None, database_project="this_will_cause_error_specify_the_database"):
+    """
+    Executes a SQL query from a file and returns the results.
+    """
+    sql_dir = os.path.join(os.path.dirname(__file__), "sql")
+    with open(os.path.join(sql_dir, filename), "r") as sql_file:
+        query = sql_file.read()
+
+    if params:
+        query, params = sql_param_to_psycopg2(query, params)
+
+    vcprint(f"Executing query:\n{query}\n", color="green")
+    vcprint(f"With params: {params}\n", color="green")
+
+    return execute_sql_query(query, params, database_project)
+
+
+def execute_transaction_query(query, params=None, database_project="this_will_cause_error_specify_the_database"):
+    """
+    Executes a SQL query within a transaction, commits it, and returns any results.
+    Suitable for INSERT/UPDATE/DELETE operations that may or may not return values.
+    """
+    conn = get_postgres_connection(database_project)
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cur:
+            if params and isinstance(params, dict):
+                query, params = sql_param_to_psycopg2(query, params)
+            cur.execute(query, params)
+            conn.commit()  # Explicitly commit the transaction
+
+            # Try to fetch results if any are available
+            try:
+                return cur.fetchall()
+            except:
+                # If no results to fetch, return an empty list instead of raising an error
+                return []
+    finally:
+        connection_pools[database_project].putconn(conn)
+
+
+def execute_batch_query(query: str, batch_params: List[Dict[str, Any]], batch_size: int = 50,
+                        database_project="supabase_automation_matrix"):
+    """
+    Executes a SQL query with batched parameters.
+    """
+    conn = get_postgres_connection(database_project)
+    all_results = []
+
+    try:
+        # Process in batches
+        for i in range(0, len(batch_params), batch_size):
+            batch = batch_params[i: i + batch_size]
+            vcprint(f"Processing batch {i // batch_size + 1}/{(len(batch_params) + batch_size - 1) // batch_size}",
+                    color="blue")
+
+            # Process each row individually within the batch
+            for idx, row_params in enumerate(batch):
+                # Handle JSONB serialization properly
+                processed_params = {}
+                for key, value in row_params.items():
+                    if key == "data" and isinstance(value, dict):
+                        # Convert dict to JSONB-compatible string
+                        processed_params[key] = json.dumps(value)
+                    else:
+                        processed_params[key] = value
+
+                # Execute the query for this row
+                with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                    if processed_params:
+                        query_with_names, params = sql_param_to_psycopg2(query, processed_params)
+                        cur.execute(query_with_names, params)
+                        conn.commit()
+                        try:
+                            result = cur.fetchall()
+                            if result:
+                                all_results.extend(result)
+                        except:
+                            # No results to fetch
+                            pass
+    finally:
+        connection_pools[database_project].putconn(conn)
+
+    return all_results

matrx_orm/constants.py

@@ -0,0 +1,141 @@
+def get_default_component_props():
+    return {
+        "subComponent": "default",
+        "variant": "default",
+        "section": "default",
+        "placeholder": "default",
+        "size": "default",
+        "textSize": "default",
+        "textColor": "default",
+        "rows": "default",
+        "animation": "default",
+        "fullWidthValue": "default",
+        "fullWidth": "default",
+        "disabled": "default",
+        "className": "default",
+        "type": "default",
+        "onChange": "default",
+        "onBlur": "default",
+        "formatString": "default",
+        "min": "default",
+        "max": "default",
+        "step": "default",
+        "numberType": "default",
+        "options": "default",
+    }
+
+
+# Method to generate the AutomationSchema
+def generate_automation_schema():  # TODO: Currently not used.
+    lines = [
+        "export type AutomationSchema = {",
+        "    [tableName in AutomationTableName]: {",
+        "        entityNameFormats: {",
+        "            frontend: string;",
+        "            backend: string;",
+        "            database: string;",
+        "            pretty: string;",
+        "            component: string;",
+        "            kebab: string;",
+        "            [key: string]: string;",
+        "        };",
+        "        schemaType: 'table' | 'view' | 'dynamic' | 'other';",
+        "        entityFields: {",
+        "            [fieldName: string]: {",
+        "                fieldNameFormats: {",
+        "                    frontend: string;",
+        "                    backend: string;",
+        "                    database: string;",
+        "                    pretty: string;",
+        "                    component: string;",
+        "                    kebab: string;",
+        "                    [key: string]: string;",
+        "                };",
+        "                dataType: DataType;",
+        "                isRequired?: boolean;",
+        "                maxLength?: number | null;",
+        "                isArray?: boolean;",
+        "                defaultValue?: any;",
+        "                isPrimaryKey?: boolean;",
+        "                defaultGeneratorFunction?: string | null;",
+        "                validationFunctions?: string[];",
+        "                exclusionRules?: string[];",
+        "                defaultComponent?: string;",
+        "                structure: 'single' | 'array' | 'object' | 'foreignKey' | 'inverseForeignKey' | 'manyToMany';",
+        "                isNative: boolean;",
+        "                typeReference: TypeBrand<any>;",
+        "                databaseTable: string;",
+        "            };",
+        "        };",
+        "        defaultFetchStrategy: 'simple' | 'fk' | 'ifk' | 'm2m' | 'fkAndIfk' | 'm2mAndFk' | 'm2mAndIfk' | 'fkIfkAndM2M';",
+        "        relationships: Array<{",
+        "            relationshipType: 'foreignKey' | 'inverseForeignKey' | 'manyToMany';",
+        "            column: string;",
+        "            relatedTable: string;",
+        "            relatedColumn: string;",
+        "            junctionTable: string | null;",
+        "        }>;",
+        "    };",
+        "};",
+    ]
+
+    return "\n".join(lines)
+
+
+def get_relationship_data_model_types():
+    ts_code_content = """
+
+    import { AnyEntityDatabaseTable, EntityKeys } from "@/types";
+
+    export type EntityRelationshipType =
+        | "self-referential"
+        | "one-to-one"
+        | "one-to-many"
+        | "many-to-one"
+        | "many-to-many";
+
+    export type ForeignKeyDetails = {
+        foreignTable: AnyEntityDatabaseTable;
+        foreignEntity: EntityKeys;
+        column: string;
+        fieldName: string;
+        foreignField: string;
+        foreignColumn: string;
+        relationshipType: EntityRelationshipType;
+        constraintName: string;
+    };
+
+    export type ReferencedByDetails = {
+        foreignTable: AnyEntityDatabaseTable;
+        foreignEntity: EntityKeys;
+        field: string;
+        column: string;
+        foreignField: string;
+        foreignColumn: string;
+        constraintName: string;
+    };
+
+    export type RelationshipDetails = {
+        entityName: EntityKeys;
+        tableName: AnyEntityDatabaseTable;
+        foreignKeys: Partial<Record<EntityKeys, ForeignKeyDetails>> | Record<string, never>;
+        referencedBy: Partial<Record<EntityKeys, ReferencedByDetails>> | Record<string, never>;
+    };
+
+    export type FullEntityRelationships = {
+        selfReferential: EntityKeys[];
+        manyToMany: EntityKeys[];
+        oneToOne: EntityKeys[];
+        manyToOne: EntityKeys[];
+        oneToMany: EntityKeys[];
+        undefined: EntityKeys[];
+        inverseReferences: EntityKeys[];
+        relationshipDetails: RelationshipDetails;
+    };
+
+    export const asEntityRelationships = (data: any): Record<EntityKeys, FullEntityRelationships> => {
+        return data as Record<EntityKeys, FullEntityRelationships>;
+    };
+
+    """
+    return ts_code_content