pygraphile 0.2.0__tar.gz → 0.3.0__tar.gz

{pygraphile-0.2.0 → pygraphile-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pygraphile
-Version: 0.2.0
+Version: 0.3.0
 Summary: A Python library inspired by PostGraphile - automatically generates GraphQL APIs from databases. Currently supports SQLite with plans for additional database support.
 Project-URL: Homepage, https://github.com/dshaw0004/pygraphile
 Project-URL: Repository, https://github.com/dshaw0004/pygraphile

{pygraphile-0.2.0 → pygraphile-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pygraphile"
-version = "0.2.0"
+version = "0.3.0"
 description = "A Python library inspired by PostGraphile - automatically generates GraphQL APIs from databases. Currently supports SQLite with plans for additional database support."
 readme = "README.md"
 authors = [

{pygraphile-0.2.0 → pygraphile-0.3.0}/src/pygraphile/__init__.py

@@ -1,4 +1,3 @@
-import sqlite3
 """
 PyGraphile - A Python library for automatically generating GraphQL APIs from databases.
 
@@ -10,8 +9,6 @@ Currently supports SQLite with plans for PostgreSQL, MySQL, and other databases.
 from .main import PyGraphile
 from .utils import get_schema_from_table_name, generate_query_type, generate_type_defs, SQL_TO_GRAPHQL
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 __author__ = "dshaw0004"
 __all__ = ["__version__", "PyGraphile", "get_schema_from_table_name", "generate_type_defs", "generate_query_type", "SQL_TO_GRAPHQL"]
-
-

pygraphile-0.3.0/src/pygraphile/main.py

@@ -0,0 +1,66 @@
+import sqlite3
+
+from ariadne import QueryType, make_executable_schema
+from ariadne.asgi import GraphQL
+
+from .utils import get_schema_from_table_name, generate_query_type, generate_type_defs
+
+__all__ = ["PyGraphile"]
+
+
+class PyGraphile:
+    def __init__(
+        self,
+        db_name: str = 'pygraphile.sqlite',
+        db_type: str = 'sqlite3',
+        migration_folder: str = 'nomigration',
+        debug: bool = False,
+    ):
+        if db_type != 'sqlite3':
+            raise ValueError(f"Unsupported database type: '{db_type}'. Currently only 'sqlite3' is supported.")
+
+        if migration_folder != 'nomigration':
+            # TODO: apply migration
+            print('need to implement this')
+
+        self._debug = debug
+        self.con = sqlite3.connect(db_name)
+        self.con.row_factory = sqlite3.Row
+        self.cursor = self.con.cursor()
+
+        result: list[tuple[str,]] = self.cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+        ).fetchall()
+        self.tables = [res[0] for res in result]
+        print(f'Following tables detected: {self.tables}')
+
+        self.table_schemas = {
+            table: get_schema_from_table_name(self.cursor, table)
+            for table in self.tables
+        }
+
+        self.gql_type_def: str = generate_type_defs(self.table_schemas)
+        self.gql_query_types: str = generate_query_type(self.table_schemas)
+
+        query = QueryType()
+
+        # dynamically attach resolvers
+        for table in self.tables:
+            query.set_field(table, self.make_resolver(table))
+
+        type_defs = self.gql_type_def + "\n" + self.gql_query_types
+        self.schema = make_executable_schema(type_defs, query)
+
+    def get_query_app(self):
+        return GraphQL(self.schema, debug=self._debug)
+
+    def make_resolver(self, table_name: str):
+        # Quote the table name to prevent SQL injection
+        safe_table = table_name.replace('"', '""')
+
+        def resolver(_, info, **kwargs):
+            sql = f'SELECT * FROM "{safe_table}"'
+            rows = self.cursor.execute(sql).fetchall()
+            return [dict(row) for row in rows]
+
+        return resolver

{pygraphile-0.2.0 → pygraphile-0.3.0}/src/pygraphile/utils.py

@@ -29,7 +29,7 @@ def generate_type_defs(tables):
     for table_name, columns in tables.items():
         fields = []
         for col in columns:
-            gql_type = SQL_TO_GRAPHQL.get(col["type"].upper(), "String")
+            gql_type = SQL_TO_GRAPHQL.get((col["type"] or "").upper(), "String")
             not_null = "!" if col["notnull"] else ""
             fields.append(f"{col['name']}: {gql_type}{not_null}")
         type_def = f"type {table_name.capitalize()} {{\n  " + \

{pygraphile-0.2.0 → pygraphile-0.3.0}/tests/test_basic.py

@@ -7,7 +7,7 @@ def test_version():
     """Test that version is defined."""
     assert hasattr(pygraphile, "__version__")
     assert isinstance(pygraphile.__version__, str)
-    assert pygraphile.__version__ == "0.1.0"
+    assert pygraphile.__version__ == "0.3.0"
 
 
 def test_module_imports():

pygraphile-0.2.0/src/pygraphile/main.py

@@ -1,70 +0,0 @@
-import sqlite3
-
-from ariadne import QueryType, make_executable_schema, gql
-from ariadne.asgi import GraphQL
-from fastapi import FastAPI
-
-from utils import get_schema_from_table_name, generate_query_type, generate_type_defs
-
-__all__ = ["PyGraphile"]
-
-
-class PyGraphile:
-    def __init__(self,
-                 db_name: str = 'pygraphile.sqlite',
-                 db_type: str = 'sqlite3',
-                 migration_folder: str = 'nomigration',
-                 ):
-
-        if 'sqlite3' != db_type:
-            print('this database is not supported yet')
-            exit(1)
-
-        if 'nomigration' != migration_folder:
-            # TODO: apply migration
-            print('need to implement this')
-
-        self.con = sqlite3.connect(db_name)
-        self.con.row_factory = sqlite3.Row
-        self.cursor = self.con.cursor()
-
-        result: list[tuple[str,]] = self.cursor.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").fetchall()
-        self.tables = [res[0] for res in result]
-        print(f'Following tables detected {self.tables}')
-
-        self.table_schemas = {table: get_schema_from_table_name(
-            self.cursor, table) for table in self.tables}
-
-        self.gql_type_def: str = generate_type_defs(self.table_schemas)
-        self.gql_query_types: str = generate_query_type(self.table_schemas)
-        print(self.gql_type_def)
-        print(self.gql_query_types)
-
-        query = QueryType()
-
-        # dynamically attach resolvers 
-        for table in self.tables: 
-            query.set_field(table, self.make_resolver(table))
-
-        type_defs = self.gql_type_def + "\n" + self.gql_query_types
-        self.schema = make_executable_schema(type_defs, query)
-
-    def get_query_app(self):
-        return GraphQL(self.schema, debug=True)
-
-    def make_resolver(self, table_name: str):
-        def resolver(_, info, **kwargs): 
-            sql = f"SELECT * FROM {table_name} LIMIT 1" 
-            rows = self.cursor.execute(sql).fetchall() 
-            return [dict(row) for row in rows] 
-        return resolver
-
-
-# if __name__ == "__main__":
-#     # initialize FastAPI 
-#     app = FastAPI() 
-#     # initialize PyGraphile 
-#     pg = PyGraphile(db_name="pygraphile.sqlite") 
-#     # mount Ariadne GraphQL app at /graphql 
-#     app.mount("/graphql", pg.get_query_app())