tapestry-orm 0.0.3__tar.gz → 0.0.4__tar.gz

{tapestry_orm-0.0.3 → tapestry_orm-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tapestry-orm
-Version: 0.0.3
+Version: 0.0.4
 Summary: A prototype ORM for SurrealDB
 Author-email: timothee@obrecht.xyz
 License-Expression: MIT

{tapestry_orm-0.0.3 → tapestry_orm-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tapestry-orm"
-version = "0.0.3"
+version = "0.0.4"
 description = "A prototype ORM for SurrealDB"
 readme = "README.md"
 license = "MIT"

{tapestry_orm-0.0.3 → tapestry_orm-0.0.4}/src/tapestry/__init__.py

@@ -1,9 +1,9 @@
-__all__ = ["Base", "Text", "create_engine", "create_engine_context", "Engine", "Reference", "Node", "Edge", "Q"]
+__all__ = ["Base", "Text", "create_engine", "create_engine_context", "Engine", "Reference", "Indexed", "Node", "Edge", "Q"]
 
 from .query import Q
 from .base import Base
 from .node import Node
 from .edge import Edge
 from .tokenizer import Text
-from .table import Reference
+from .table import Reference, Indexed
 from .engine import create_engine, create_engine_context, Engine

{tapestry_orm-0.0.3 → tapestry_orm-0.0.4}/src/tapestry/table.py

@@ -17,6 +17,26 @@ from .utils import flatten_type
 from .tokenizer import Text, Tokenizer, FrenchTokenizer
 
 
+@dataclass(frozen=True)
+class Indexed:
+    """Opt-in index annotation for model fields.
+
+    Use with ``typing.Annotated`` to request a database index on a field::
+
+        from typing import Annotated
+        from tapestry import Node, Indexed
+
+        class Person(Node):
+            ext_id: Annotated[str | None, Indexed(unique=True)] = None
+            party: Annotated[str | None, Indexed()] = None
+
+    Attributes:
+        unique: If True, the index enforces uniqueness.
+    """
+
+    unique: bool = False
+
+
 @dataclass(frozen=True)
 class Link:
     _in: type[Any]
@@ -86,11 +106,18 @@ class Table:
     relation: Link | None = None
     index: dict[str, str] = field(default_factory=dict)
     tokenizers: tuple[Tokenizer, ...] = ()
+    record_link_fields: tuple[str, ...] = ()
+    indexed_fields: dict[str, bool] = field(default_factory=dict)
 
     def __post_init__(self):
         indices = {}
         tokenizers = []
+        record_links = []
+        opt_in: dict[str, bool] = {}
+
         for field in self.fields:
+            if field.name in ("id", "is_stub_"):
+                continue
             if field.field_type:
                 for tp in tuple(flatten_type(field.field_type, base_type=Text)):
                     if inspect.isclass(tp) and issubclass(tp, Text):
@@ -105,9 +132,44 @@ class Table:
                         if not args or not issubclass(args[0], self.base_class):
                             raise TypeError("References must point to a Node class")
 
+                # Detect record link fields (foreign keys)
+                if self._is_record_link_type(field.field_type):
+                    record_links.append(field.name)
+
+        # Detect opt-in Indexed metadata from Pydantic FieldInfo
+        if hasattr(self.model_class, "model_fields"):
+            for fname, finfo in self.model_class.model_fields.items():
+                if hasattr(finfo, "metadata") and finfo.metadata:
+                    for meta in finfo.metadata:
+                        if isinstance(meta, Indexed):
+                            opt_in[fname] = meta.unique
+                            break
+
         object.__setattr__(self, "index", indices)
         object.__setattr__(self, "tokenizers", tuple(tokenizers))
         object.__setattr__(self, "name_to_type", {f.name: f.field_type for f in self.fields})
+        object.__setattr__(self, "record_link_fields", tuple(record_links))
+        object.__setattr__(self, "indexed_fields", opt_in)
+
+    def _is_record_link_type(self, tp: Any) -> bool:
+        """Check whether *tp* resolves to a direct record link.
+
+        Returns ``True`` when the type is (or contains via Union) a subclass
+        of ``self.base_class``, but does **not** recurse into generic
+        containers like ``list[...]`` or ``set[...]``.
+        """
+        if tp is type(None):
+            return False
+        try:
+            if inspect.isclass(tp) and issubclass(tp, self.base_class):
+                return True
+        except TypeError:
+            return False
+        origin = get_origin(tp)
+        args = get_args(tp)
+        if origin is types.UnionType or (origin is not None and hasattr(origin, "__name__") and origin.__name__ == "UnionType"):
+            return any(self._is_record_link_type(a) for a in (args or ()))
+        return False
 
     # -------------------- helpers to map python type -> surreal type ----------
 
@@ -438,7 +500,7 @@ class Table:
         return getattr(tp, "__name__", str(tp)).lower()
 
     def generate_table_sql(self) -> str:
-        stmts = []
+        stmts: list[str] = []
         if self.relation:
             in_tbl = self._pytype_to_surreal("_in", self.relation._in)
             out_tbl = self._pytype_to_surreal("_out", self.relation._out)
@@ -458,8 +520,26 @@ class Table:
             surreal_t = self._pytype_to_surreal(ft.name, ft.field_type)
             stmts.append(f"DEFINE FIELD {self._quote_ident(ft.name)} ON {self.name} TYPE {surreal_t};")
 
-        define_index = [
-            f"DEFINE INDEX {field}_search ON TABLE {self.name} FIELDS {field} FULLTEXT ANALYZER {analyzer} BM25 HIGHLIGHTS;"
-            for field, analyzer in self.index.items()
-        ]
-        return "\n".join(stmts) + "\n" + "\n".join(define_index)
+        # -- Indexes -----------------------------------------------------------
+
+        # Auto-index edge in/out fields
+        if self.relation is not None:
+            stmts.append(f"DEFINE INDEX idx_{self.name}_in ON TABLE {self.name} FIELDS in;")
+            stmts.append(f"DEFINE INDEX idx_{self.name}_out ON TABLE {self.name} FIELDS out;")
+
+        # Auto-index record link fields (foreign keys)
+        for field_name in self.record_link_fields:
+            stmts.append(f"DEFINE INDEX idx_{self.name}_{field_name} ON TABLE {self.name} FIELDS {field_name};")
+
+        # Opt-in indexed fields
+        for field_name, unique in self.indexed_fields.items():
+            unique_suffix = " UNIQUE" if unique else ""
+            stmts.append(f"DEFINE INDEX idx_{self.name}_{field_name} ON TABLE {self.name} FIELDS {field_name}{unique_suffix};")
+
+        # Fulltext search indexes (preserve existing naming convention)
+        for field, analyzer in self.index.items():
+            stmts.append(
+                f"DEFINE INDEX {field}_search ON TABLE {self.name} FIELDS {field} FULLTEXT ANALYZER {analyzer} BM25 HIGHLIGHTS;"
+            )
+
+        return "\n".join(stmts)