devdb-sql 1.0.4__tar.gz → 1.0.5__tar.gz

{devdb_sql-1.0.4 → devdb_sql-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devdb-sql
-Version: 1.0.4
+Version: 1.0.5
 Summary: Lightweight SQLite SDK with a MongoDB-like developer experience
 Author: Mahadev
 License: MIT

devdb_sql-1.0.5/devdb/__init__.py

@@ -0,0 +1,5 @@
+from .db import DB
+from .table import Table
+
+__all__ = ["DB", "Table"]
+__version__ = "1.0.2"

devdb_sql-1.0.5/devdb/db.py

@@ -0,0 +1,61 @@
+import sqlite3
+from pathlib import Path
+
+from .schema import compile_schema
+from .table import Table
+
+
+class DB:
+    def __init__(self, path):
+        if not path:
+            raise ValueError("Database path is required")
+
+        self.path = path
+
+        parent = Path(path).parent
+        if str(parent) not in ("", "."):
+            parent.mkdir(parents=True, exist_ok=True)
+
+        self.sqlite = sqlite3.connect(path)
+        self.sqlite.row_factory = sqlite3.Row
+        self._tables = {}
+
+    def create(self, name, schema):
+        if not name:
+            raise ValueError("Table name is required")
+
+        if not isinstance(schema, dict):
+            raise ValueError(f'Schema is required for table "{name}"')
+
+        if name in self._tables:
+            raise ValueError(f'Table "{name}" is already registered')
+
+        sql = compile_schema(name, schema)
+        self.sqlite.executescript(sql)
+        self.sqlite.commit()
+
+        table = Table(self, name, schema)
+        self._tables[name] = table
+        return table
+
+    def drop(self, name):
+        self.sqlite.execute(f"DROP TABLE IF EXISTS {name}")
+        self.sqlite.commit()
+        self._tables.pop(name, None)
+        return True
+
+    def tables(self):
+        rows = self.sqlite.execute("""
+            SELECT name
+            FROM sqlite_master
+            WHERE type = 'table'
+              AND name NOT LIKE 'sqlite_%'
+            ORDER BY name
+        """).fetchall()
+        return [row["name"] for row in rows]
+
+    def show_tables(self):
+        return self.tables()
+
+    def close(self):
+        self.sqlite.close()

devdb_sql-1.0.5/devdb/schema.py

@@ -0,0 +1,98 @@
+import re
+
+TYPE_MAP = {
+    "string": "TEXT",
+    "integer": "INTEGER",
+    "number": "REAL",
+    "boolean": "INTEGER",
+    "date": "TEXT",
+    "json": "TEXT",
+}
+
+_IDENTIFIER = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+
+
+def validate_identifier(name):
+    if not isinstance(name, str) or not _IDENTIFIER.fullmatch(name):
+        raise ValueError(f"Invalid SQL identifier: {name}")
+
+
+def compile_default(value, sql_type):
+    if value is None:
+        return "NULL"
+
+    if sql_type in ("INTEGER", "REAL"):
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise ValueError("Numeric default value expected")
+        return str(value)
+
+    if not isinstance(value, str):
+        raise ValueError("String default value expected")
+
+    return "'" + value.replace("'", "''") + "'"
+
+
+def compile_schema(table_name, schema):
+    validate_identifier(table_name)
+
+    if not isinstance(schema, dict):
+        raise ValueError("Schema must be an object")
+
+    columns = []
+
+    for name, config in schema.items():
+        validate_identifier(name)
+
+        if not isinstance(config, dict):
+            raise ValueError(f'Invalid configuration for field "{name}"')
+
+        field_type = config.get("type")
+        sql_type = TYPE_MAP.get(field_type)
+
+        if not sql_type:
+            raise ValueError(
+                f'Unsupported type "{field_type}" for field "{name}"'
+            )
+
+        definition = f"{name} {sql_type}"
+
+        if config.get("primary"):
+            definition += " PRIMARY KEY"
+
+        if config.get("autoIncrement"):
+            if sql_type != "INTEGER" or not config.get("primary"):
+                raise ValueError(
+                    f'autoIncrement requires INTEGER PRIMARY KEY for "{name}"'
+                )
+            definition += " AUTOINCREMENT"
+
+        if config.get("required"):
+            definition += " NOT NULL"
+
+        if config.get("unique"):
+            definition += " UNIQUE"
+
+        if "default" in config:
+            definition += f" DEFAULT {compile_default(config['default'], sql_type)}"
+
+        columns.append(definition)
+
+    if not columns:
+        raise ValueError("Schema cannot be empty")
+
+    return f"""
+CREATE TABLE IF NOT EXISTS {table_name} (
+  {", ".join(columns)}
+)
+"""
+
+
+def get_primary_key(schema):
+    for name, config in schema.items():
+        if config.get("primary"):
+            return name
+    raise ValueError("Schema must contain a primary key")
+
+
+def get_sql_type(field_type):
+    return TYPE_MAP.get(field_type)

devdb_sql-1.0.5/devdb/table.py

@@ -0,0 +1,253 @@
+import json
+import sqlite3
+
+from .schema import get_primary_key
+
+
+class Table:
+    def __init__(self, db, name, schema):
+        self.db = db
+        self.name = name
+        self.schema = schema
+        self.primary_key = get_primary_key(schema)
+
+    def _check_field(self, field):
+        if field not in self.schema:
+            raise ValueError(
+                f'Unknown field "{field}" in table "{self.name}"'
+            )
+
+    def _serialize_value(self, field, value):
+        field_type = self.schema[field].get("type")
+
+        if field_type == "string" and not isinstance(value, str):
+            raise ValueError(f"{field} must be a string")
+
+        if field_type in ("integer", "number"):
+            if isinstance(value, bool) or not isinstance(value, (int, float)):
+                raise ValueError(f"{field} must be a number")
+
+        if field_type == "boolean":
+            if not isinstance(value, bool):
+                raise ValueError(f"{field} must be a boolean")
+            return 1 if value else 0
+
+        if field_type == "json":
+            return json.dumps(value, separators=(",", ":"))
+
+        return value
+
+    def _row_to_dict(self, row):
+        if row is None:
+            return None
+
+        result = dict(row)
+
+        for field, config in self.schema.items():
+            if field not in result:
+                continue
+
+            if config.get("type") == "boolean" and result[field] is not None:
+                result[field] = bool(result[field])
+
+        return result
+
+    def insert(self, data):
+        if not isinstance(data, dict):
+            raise ValueError("Insert data must be an object")
+
+        fields = list(data.keys())
+
+        if not fields:
+            raise ValueError("Insert data cannot be empty")
+
+        for field in fields:
+            self._check_field(field)
+
+        columns = ", ".join(fields)
+        placeholders = ", ".join("?" for _ in fields)
+        values = [
+            self._serialize_value(field, data[field])
+            for field in fields
+        ]
+
+        sql = f"""
+INSERT INTO {self.name} ({columns})
+VALUES ({placeholders})
+"""
+
+        cursor = self.db.sqlite.execute(sql, values)
+        self.db.sqlite.commit()
+
+        # Preserve the JS SDK's insert -> findById behavior.
+        return self.find_by_id(cursor.lastrowid)
+
+    def find_by_id(self, id):
+        sql = f"""
+SELECT *
+FROM {self.name}
+WHERE {self.primary_key} = ?
+LIMIT 1
+"""
+
+        row = self.db.sqlite.execute(sql, (id,)).fetchone()
+        return self._row_to_dict(row)
+
+    def find_all(self):
+        rows = self.db.sqlite.execute(
+            f"SELECT * FROM {self.name}"
+        ).fetchall()
+        return [self._row_to_dict(row) for row in rows]
+
+    def find(self, query=None, options=None):
+        if query is None:
+            query = {}
+        if options is None:
+            options = {}
+
+        if not isinstance(query, dict):
+            raise ValueError("Query must be an object")
+
+        if not isinstance(options, dict):
+            raise ValueError("Options must be an object")
+
+        conditions = []
+        values = []
+
+        for field, condition in query.items():
+            self._check_field(field)
+
+            if isinstance(condition, dict):
+                for operator, value in condition.items():
+                    if operator == "$eq":
+                        conditions.append(f"{field} = ?")
+                        values.append(self._serialize_query_value(field, value))
+
+                    elif operator == "$ne":
+                        conditions.append(f"{field} != ?")
+                        values.append(self._serialize_query_value(field, value))
+
+                    elif operator == "$gt":
+                        conditions.append(f"{field} > ?")
+                        values.append(self._serialize_query_value(field, value))
+
+                    elif operator == "$gte":
+                        conditions.append(f"{field} >= ?")
+                        values.append(self._serialize_query_value(field, value))
+
+                    elif operator == "$lt":
+                        conditions.append(f"{field} < ?")
+                        values.append(self._serialize_query_value(field, value))
+
+                    elif operator == "$lte":
+                        conditions.append(f"{field} <= ?")
+                        values.append(self._serialize_query_value(field, value))
+
+                    elif operator == "$in":
+                        if not isinstance(value, list) or not value:
+                            raise ValueError("$in requires a non-empty array")
+
+                        placeholders = ", ".join("?" for _ in value)
+                        conditions.append(f"{field} IN ({placeholders})")
+                        values.extend(
+                            self._serialize_query_value(field, item)
+                            for item in value
+                        )
+
+                    else:
+                        raise ValueError(f'Unsupported operator "{operator}"')
+            else:
+                conditions.append(f"{field} = ?")
+                values.append(self._serialize_query_value(field, condition))
+
+        sql = f"SELECT * FROM {self.name}"
+
+        if conditions:
+            sql += " WHERE " + " AND ".join(conditions)
+
+        order_by = options.get("orderBy")
+        if order_by:
+            self._check_field(order_by)
+            order = "DESC" if options.get("order") == "desc" else "ASC"
+            sql += f" ORDER BY {order_by} {order}"
+
+        if "limit" in options:
+            limit = options["limit"]
+            if isinstance(limit, bool) or not isinstance(limit, int) or limit < 0:
+                raise ValueError("limit must be a positive integer")
+            sql += f" LIMIT {limit}"
+
+        if "offset" in options:
+            offset = options["offset"]
+            if isinstance(offset, bool) or not isinstance(offset, int) or offset < 0:
+                raise ValueError("offset must be a positive integer")
+            sql += f" OFFSET {offset}"
+
+        rows = self.db.sqlite.execute(sql, values).fetchall()
+        return [self._row_to_dict(row) for row in rows]
+
+    def _serialize_query_value(self, field, value):
+        field_type = self.schema[field].get("type")
+        if field_type == "boolean":
+            if not isinstance(value, bool):
+                raise ValueError(f"{field} must be a boolean")
+            return 1 if value else 0
+        if field_type == "json":
+            return json.dumps(value, separators=(",", ":"))
+        return value
+
+    def update_by_id(self, id, data):
+        if not isinstance(data, dict):
+            raise ValueError("Update data must be an object")
+
+        fields = list(data.keys())
+
+        if not fields:
+            raise ValueError("Update data cannot be empty")
+
+        for field in fields:
+            self._check_field(field)
+
+            if field == self.primary_key:
+                raise ValueError("Primary key cannot be updated")
+
+        set_clause = ", ".join(f"{field} = ?" for field in fields)
+        values = [
+            self._serialize_value(field, data[field])
+            for field in fields
+        ]
+        values.append(id)
+
+        sql = f"""
+UPDATE {self.name}
+SET {set_clause}
+WHERE {self.primary_key} = ?
+"""
+
+        cursor = self.db.sqlite.execute(sql, values)
+        self.db.sqlite.commit()
+
+        if cursor.rowcount == 0:
+            return None
+
+        return self.find_by_id(id)
+
+    def delete_by_id(self, id):
+        cursor = self.db.sqlite.execute(
+            f"DELETE FROM {self.name} WHERE {self.primary_key} = ?",
+            (id,),
+        )
+        self.db.sqlite.commit()
+        return cursor.rowcount > 0
+
+    def drop(self):
+        self.db.sqlite.execute(f"DROP TABLE IF EXISTS {self.name}")
+        self.db.sqlite.commit()
+        self.db._tables.pop(self.name, None)
+        return True
+
+    # JS-compatible aliases
+    findById = find_by_id
+    findAll = find_all
+    updateById = update_by_id
+    deleteById = delete_by_id

{devdb_sql-1.0.4 → devdb_sql-1.0.5}/devdb_sql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devdb-sql
-Version: 1.0.4
+Version: 1.0.5
 Summary: Lightweight SQLite SDK with a MongoDB-like developer experience
 Author: Mahadev
 License: MIT

{devdb_sql-1.0.4 → devdb_sql-1.0.5}/devdb_sql.egg-info/SOURCES.txt

@@ -1,6 +1,10 @@
 LICENSE
 README.md
 pyproject.toml
+devdb/__init__.py
+devdb/db.py
+devdb/schema.py
+devdb/table.py
 devdb_sql.egg-info/PKG-INFO
 devdb_sql.egg-info/SOURCES.txt
 devdb_sql.egg-info/dependency_links.txt

devdb_sql-1.0.5/devdb_sql.egg-info/top_level.txt

@@ -0,0 +1 @@
+devdb

{devdb_sql-1.0.4 → devdb_sql-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devdb-sql"
-version = "1.0.4"
+version = "1.0.5"
 description = "Lightweight SQLite SDK with a MongoDB-like developer experience"
 readme = "README.md"
 requires-python = ">=3.9"

devdb_sql-1.0.4/devdb_sql.egg-info/top_level.txt

@@ -1 +0,0 @@
-