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

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

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

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

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

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

@@ -1,10 +1,6 @@
 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.6/devdb_sql.egg-info/top_level.txt

@@ -0,0 +1 @@
+

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

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

devdb_sql-1.0.5/devdb/__init__.py

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

devdb_sql-1.0.5/devdb/db.py

@@ -1,61 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,253 +0,0 @@
-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.5/devdb_sql.egg-info/top_level.txt

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