moss-connector-supabase 0.0.1__tar.gz

moss_connector_supabase-0.0.1/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: moss-connector-supabase
+Version: 0.0.1
+Summary: Supabase source connector for moss-connectors.
+Author-email: "InferEdge Inc." <contact@moss.dev>
+License: BSD-2-Clause
+Project-URL: Homepage, https://github.com/usemoss/moss
+Project-URL: Repository, https://github.com/usemoss/moss
+Project-URL: Source, https://github.com/usemoss/moss/tree/main/packages/moss-data-connector/moss-connector-supabase
+Keywords: moss,connectors,supabase,postgres,ingest,etl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: moss>=1.1.1
+Requires-Dist: supabase>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+
+# moss-connector-supabase
+
+Supabase source connector for Moss. Uses [supabase-py](https://github.com/supabase/supabase-py) to read rows from a Supabase table over PostgREST.
+
+## Install
+
+```bash
+pip install moss-connector-supabase
+```
+
+This installs `supabase` automatically.
+
+## Usage
+
+```python
+import asyncio
+from moss import DocumentInfo
+from moss_connector_supabase import SupabaseConnector, ingest
+
+async def main():
+    source = SupabaseConnector(
+        url="https://xxx.supabase.co",
+        key="your-anon-or-service-key",
+        table="articles",
+        mapper=lambda row: DocumentInfo(
+            id=str(row["id"]),
+            text=row["body"],
+            metadata={"title": row["title"]},
+        ),
+    )
+
+    result = await ingest(
+        source,
+        project_id="your_project_id",
+        project_key="your_project_key",
+        index_name="articles",
+    )
+    print(f"copied {result.doc_count} rows")
+
+asyncio.run(main())
+```
+
+Use `auto_id=True` when your mapper does not have a stable primary key and you want Moss to generate UUID document IDs.
+
+## Data requirements
+
+The connector doesn't impose a schema — it reads each row as a dict and passes it to your `mapper`. The constraints come from `DocumentInfo`, not the connector.
+
+`DocumentInfo` fields:
+
+| Field | Type | Required? | Typical Supabase column |
+|---|---|---|---|
+| `id` | `str` | yes | a primary key — `int`, `uuid`, slug, etc. |
+| `text` | `str` | yes | the column you want to search (`body`, `description`, `content`...) |
+| `metadata` | `Optional[Dict[str, str]]` | no | any other columns you want filterable / displayable |
+| `embedding` | `Optional[Sequence[float]]` | no | only if you bring your own vectors with `model_id="custom"` |
+
+So your table needs **at least one stringifiable column** to use as `id` and **at least one text column** to use as `text`. Everything else is optional. Examples:
+
+**Minimal** — `id` + `body`:
+
+```sql
+CREATE TABLE notes (id int PRIMARY KEY, body text);
+```
+```python
+mapper=lambda row: DocumentInfo(id=str(row["id"]), text=row["body"])
+```
+
+**Rich** — extra columns flow into metadata:
+
+```sql
+CREATE TABLE articles (
+    id           uuid PRIMARY KEY,
+    title        text,
+    body         text,
+    author       text,
+    published_at timestamptz,
+    view_count   int,
+    tags         text[]
+);
+```
+```python
+mapper=lambda row: DocumentInfo(
+    id=row["id"],
+    text=row["body"],
+    metadata={
+        "title": row["title"],
+        "author": row["author"],
+        "published_at": str(row["published_at"]),  # timestamp -> str
+        "view_count": str(row["view_count"]),      # int -> str
+        "tags": ",".join(row["tags"]),             # array -> joined str
+    },
+)
+```
+
+### One gotcha: metadata values must be strings
+
+Postgres types like `int`, `bool`, `timestamp`, `numeric`, `array`, `jsonb` come back from Supabase as their native Python types (`int`, `bool`, `datetime`, `list`, `dict`). `DocumentInfo.metadata` requires `Dict[str, str]`, so non-string columns must be coerced in the mapper:
+
+```python
+# WILL FAIL — non-string values
+metadata={"price": row["price"], "in_stock": row["in_stock"]}
+
+# CORRECT
+metadata={"price": str(row["price"]), "in_stock": str(row["in_stock"])}
+```
+
+The same applies to `id` if your primary key is an `int` — wrap with `str(...)`.
+
+### What you can't do (use a view instead)
+
+- **Joins across tables** — read-from-one-table only. Combine in a Postgres view (`CREATE VIEW articles_with_author AS SELECT a.*, u.name AS author_name FROM articles a JOIN users u ON ...`) and point the connector at the view.
+- **Filter rows in Python** — there's no `filter=` kwarg (see [Filtering](#filtering)). Use a view to pre-filter server-side.
+
+## Choosing a key
+
+The `key` argument controls which rows are visible:
+
+- **anon key** — only rows allowed by your Row-Level Security policies. Use this for ingesting publicly readable content.
+- **service-role key** — bypasses RLS. Use this for full-table ingest in trusted backend jobs. Never ship a service-role key to a client.
+
+The connector does not enforce this; pick the right key for your use case.
+
+## Filtering
+
+The connector reads every row in the named table. To restrict ingest to a subset, create a Postgres view in Supabase and point the connector at the view:
+
+```sql
+CREATE VIEW search_corpus AS
+  SELECT id, title, body FROM articles WHERE published = true;
+```
+
+```python
+SupabaseConnector(table="search_corpus", ...)
+```
+
+A `filter=` kwarg is intentionally not exposed in v1 — Supabase's filter API is method-chained and doesn't fit a single-kwarg shape cleanly. If you need parameterized server-side filtering, open an issue.
+
+## Pagination
+
+PostgREST is HTTP-only with no streaming cursor, so the connector pages with `.range(start, end)`. Default `page_size=1000` matches PostgREST's default `db-max-rows` cap. **Do not raise this above your project's server-side cap** — PostgREST silently truncates the response, the connector sees a short page, and stops, missing the rest of the table.
+
+## Layout
+
+```
+src/
+├── __init__.py      # re-exports SupabaseConnector and ingest
+├── connector.py     # SupabaseConnector class
+└── ingest.py        # ingest() - keep in sync with the other connector packages
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/test_supabase.py -v                          # mocked, no network needed
+pytest tests/test_integration_supabase_moss.py -v -s      # live Supabase + Moss
+```
+
+The integration test requires `SUPABASE_URL`, `SUPABASE_KEY`, `MOSS_PROJECT_ID`, `MOSS_PROJECT_KEY`, and `SUPABASE_TEST_TABLE` (a pre-created table with `id`, `title`, `body` columns; supabase-py can't create tables over PostgREST).

moss_connector_supabase-0.0.1/README.md

@@ -0,0 +1,160 @@
+# moss-connector-supabase
+
+Supabase source connector for Moss. Uses [supabase-py](https://github.com/supabase/supabase-py) to read rows from a Supabase table over PostgREST.
+
+## Install
+
+```bash
+pip install moss-connector-supabase
+```
+
+This installs `supabase` automatically.
+
+## Usage
+
+```python
+import asyncio
+from moss import DocumentInfo
+from moss_connector_supabase import SupabaseConnector, ingest
+
+async def main():
+    source = SupabaseConnector(
+        url="https://xxx.supabase.co",
+        key="your-anon-or-service-key",
+        table="articles",
+        mapper=lambda row: DocumentInfo(
+            id=str(row["id"]),
+            text=row["body"],
+            metadata={"title": row["title"]},
+        ),
+    )
+
+    result = await ingest(
+        source,
+        project_id="your_project_id",
+        project_key="your_project_key",
+        index_name="articles",
+    )
+    print(f"copied {result.doc_count} rows")
+
+asyncio.run(main())
+```
+
+Use `auto_id=True` when your mapper does not have a stable primary key and you want Moss to generate UUID document IDs.
+
+## Data requirements
+
+The connector doesn't impose a schema — it reads each row as a dict and passes it to your `mapper`. The constraints come from `DocumentInfo`, not the connector.
+
+`DocumentInfo` fields:
+
+| Field | Type | Required? | Typical Supabase column |
+|---|---|---|---|
+| `id` | `str` | yes | a primary key — `int`, `uuid`, slug, etc. |
+| `text` | `str` | yes | the column you want to search (`body`, `description`, `content`...) |
+| `metadata` | `Optional[Dict[str, str]]` | no | any other columns you want filterable / displayable |
+| `embedding` | `Optional[Sequence[float]]` | no | only if you bring your own vectors with `model_id="custom"` |
+
+So your table needs **at least one stringifiable column** to use as `id` and **at least one text column** to use as `text`. Everything else is optional. Examples:
+
+**Minimal** — `id` + `body`:
+
+```sql
+CREATE TABLE notes (id int PRIMARY KEY, body text);
+```
+```python
+mapper=lambda row: DocumentInfo(id=str(row["id"]), text=row["body"])
+```
+
+**Rich** — extra columns flow into metadata:
+
+```sql
+CREATE TABLE articles (
+    id           uuid PRIMARY KEY,
+    title        text,
+    body         text,
+    author       text,
+    published_at timestamptz,
+    view_count   int,
+    tags         text[]
+);
+```
+```python
+mapper=lambda row: DocumentInfo(
+    id=row["id"],
+    text=row["body"],
+    metadata={
+        "title": row["title"],
+        "author": row["author"],
+        "published_at": str(row["published_at"]),  # timestamp -> str
+        "view_count": str(row["view_count"]),      # int -> str
+        "tags": ",".join(row["tags"]),             # array -> joined str
+    },
+)
+```
+
+### One gotcha: metadata values must be strings
+
+Postgres types like `int`, `bool`, `timestamp`, `numeric`, `array`, `jsonb` come back from Supabase as their native Python types (`int`, `bool`, `datetime`, `list`, `dict`). `DocumentInfo.metadata` requires `Dict[str, str]`, so non-string columns must be coerced in the mapper:
+
+```python
+# WILL FAIL — non-string values
+metadata={"price": row["price"], "in_stock": row["in_stock"]}
+
+# CORRECT
+metadata={"price": str(row["price"]), "in_stock": str(row["in_stock"])}
+```
+
+The same applies to `id` if your primary key is an `int` — wrap with `str(...)`.
+
+### What you can't do (use a view instead)
+
+- **Joins across tables** — read-from-one-table only. Combine in a Postgres view (`CREATE VIEW articles_with_author AS SELECT a.*, u.name AS author_name FROM articles a JOIN users u ON ...`) and point the connector at the view.
+- **Filter rows in Python** — there's no `filter=` kwarg (see [Filtering](#filtering)). Use a view to pre-filter server-side.
+
+## Choosing a key
+
+The `key` argument controls which rows are visible:
+
+- **anon key** — only rows allowed by your Row-Level Security policies. Use this for ingesting publicly readable content.
+- **service-role key** — bypasses RLS. Use this for full-table ingest in trusted backend jobs. Never ship a service-role key to a client.
+
+The connector does not enforce this; pick the right key for your use case.
+
+## Filtering
+
+The connector reads every row in the named table. To restrict ingest to a subset, create a Postgres view in Supabase and point the connector at the view:
+
+```sql
+CREATE VIEW search_corpus AS
+  SELECT id, title, body FROM articles WHERE published = true;
+```
+
+```python
+SupabaseConnector(table="search_corpus", ...)
+```
+
+A `filter=` kwarg is intentionally not exposed in v1 — Supabase's filter API is method-chained and doesn't fit a single-kwarg shape cleanly. If you need parameterized server-side filtering, open an issue.
+
+## Pagination
+
+PostgREST is HTTP-only with no streaming cursor, so the connector pages with `.range(start, end)`. Default `page_size=1000` matches PostgREST's default `db-max-rows` cap. **Do not raise this above your project's server-side cap** — PostgREST silently truncates the response, the connector sees a short page, and stops, missing the rest of the table.
+
+## Layout
+
+```
+src/
+├── __init__.py      # re-exports SupabaseConnector and ingest
+├── connector.py     # SupabaseConnector class
+└── ingest.py        # ingest() - keep in sync with the other connector packages
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/test_supabase.py -v                          # mocked, no network needed
+pytest tests/test_integration_supabase_moss.py -v -s      # live Supabase + Moss
+```
+
+The integration test requires `SUPABASE_URL`, `SUPABASE_KEY`, `MOSS_PROJECT_ID`, `MOSS_PROJECT_KEY`, and `SUPABASE_TEST_TABLE` (a pre-created table with `id`, `title`, `body` columns; supabase-py can't create tables over PostgREST).

moss_connector_supabase-0.0.1/moss_connector_supabase.egg-info/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: moss-connector-supabase
+Version: 0.0.1
+Summary: Supabase source connector for moss-connectors.
+Author-email: "InferEdge Inc." <contact@moss.dev>
+License: BSD-2-Clause
+Project-URL: Homepage, https://github.com/usemoss/moss
+Project-URL: Repository, https://github.com/usemoss/moss
+Project-URL: Source, https://github.com/usemoss/moss/tree/main/packages/moss-data-connector/moss-connector-supabase
+Keywords: moss,connectors,supabase,postgres,ingest,etl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: moss>=1.1.1
+Requires-Dist: supabase>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+
+# moss-connector-supabase
+
+Supabase source connector for Moss. Uses [supabase-py](https://github.com/supabase/supabase-py) to read rows from a Supabase table over PostgREST.
+
+## Install
+
+```bash
+pip install moss-connector-supabase
+```
+
+This installs `supabase` automatically.
+
+## Usage
+
+```python
+import asyncio
+from moss import DocumentInfo
+from moss_connector_supabase import SupabaseConnector, ingest
+
+async def main():
+    source = SupabaseConnector(
+        url="https://xxx.supabase.co",
+        key="your-anon-or-service-key",
+        table="articles",
+        mapper=lambda row: DocumentInfo(
+            id=str(row["id"]),
+            text=row["body"],
+            metadata={"title": row["title"]},
+        ),
+    )
+
+    result = await ingest(
+        source,
+        project_id="your_project_id",
+        project_key="your_project_key",
+        index_name="articles",
+    )
+    print(f"copied {result.doc_count} rows")
+
+asyncio.run(main())
+```
+
+Use `auto_id=True` when your mapper does not have a stable primary key and you want Moss to generate UUID document IDs.
+
+## Data requirements
+
+The connector doesn't impose a schema — it reads each row as a dict and passes it to your `mapper`. The constraints come from `DocumentInfo`, not the connector.
+
+`DocumentInfo` fields:
+
+| Field | Type | Required? | Typical Supabase column |
+|---|---|---|---|
+| `id` | `str` | yes | a primary key — `int`, `uuid`, slug, etc. |
+| `text` | `str` | yes | the column you want to search (`body`, `description`, `content`...) |
+| `metadata` | `Optional[Dict[str, str]]` | no | any other columns you want filterable / displayable |
+| `embedding` | `Optional[Sequence[float]]` | no | only if you bring your own vectors with `model_id="custom"` |
+
+So your table needs **at least one stringifiable column** to use as `id` and **at least one text column** to use as `text`. Everything else is optional. Examples:
+
+**Minimal** — `id` + `body`:
+
+```sql
+CREATE TABLE notes (id int PRIMARY KEY, body text);
+```
+```python
+mapper=lambda row: DocumentInfo(id=str(row["id"]), text=row["body"])
+```
+
+**Rich** — extra columns flow into metadata:
+
+```sql
+CREATE TABLE articles (
+    id           uuid PRIMARY KEY,
+    title        text,
+    body         text,
+    author       text,
+    published_at timestamptz,
+    view_count   int,
+    tags         text[]
+);
+```
+```python
+mapper=lambda row: DocumentInfo(
+    id=row["id"],
+    text=row["body"],
+    metadata={
+        "title": row["title"],
+        "author": row["author"],
+        "published_at": str(row["published_at"]),  # timestamp -> str
+        "view_count": str(row["view_count"]),      # int -> str
+        "tags": ",".join(row["tags"]),             # array -> joined str
+    },
+)
+```
+
+### One gotcha: metadata values must be strings
+
+Postgres types like `int`, `bool`, `timestamp`, `numeric`, `array`, `jsonb` come back from Supabase as their native Python types (`int`, `bool`, `datetime`, `list`, `dict`). `DocumentInfo.metadata` requires `Dict[str, str]`, so non-string columns must be coerced in the mapper:
+
+```python
+# WILL FAIL — non-string values
+metadata={"price": row["price"], "in_stock": row["in_stock"]}
+
+# CORRECT
+metadata={"price": str(row["price"]), "in_stock": str(row["in_stock"])}
+```
+
+The same applies to `id` if your primary key is an `int` — wrap with `str(...)`.
+
+### What you can't do (use a view instead)
+
+- **Joins across tables** — read-from-one-table only. Combine in a Postgres view (`CREATE VIEW articles_with_author AS SELECT a.*, u.name AS author_name FROM articles a JOIN users u ON ...`) and point the connector at the view.
+- **Filter rows in Python** — there's no `filter=` kwarg (see [Filtering](#filtering)). Use a view to pre-filter server-side.
+
+## Choosing a key
+
+The `key` argument controls which rows are visible:
+
+- **anon key** — only rows allowed by your Row-Level Security policies. Use this for ingesting publicly readable content.
+- **service-role key** — bypasses RLS. Use this for full-table ingest in trusted backend jobs. Never ship a service-role key to a client.
+
+The connector does not enforce this; pick the right key for your use case.
+
+## Filtering
+
+The connector reads every row in the named table. To restrict ingest to a subset, create a Postgres view in Supabase and point the connector at the view:
+
+```sql
+CREATE VIEW search_corpus AS
+  SELECT id, title, body FROM articles WHERE published = true;
+```
+
+```python
+SupabaseConnector(table="search_corpus", ...)
+```
+
+A `filter=` kwarg is intentionally not exposed in v1 — Supabase's filter API is method-chained and doesn't fit a single-kwarg shape cleanly. If you need parameterized server-side filtering, open an issue.
+
+## Pagination
+
+PostgREST is HTTP-only with no streaming cursor, so the connector pages with `.range(start, end)`. Default `page_size=1000` matches PostgREST's default `db-max-rows` cap. **Do not raise this above your project's server-side cap** — PostgREST silently truncates the response, the connector sees a short page, and stops, missing the rest of the table.
+
+## Layout
+
+```
+src/
+├── __init__.py      # re-exports SupabaseConnector and ingest
+├── connector.py     # SupabaseConnector class
+└── ingest.py        # ingest() - keep in sync with the other connector packages
+```
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/test_supabase.py -v                          # mocked, no network needed
+pytest tests/test_integration_supabase_moss.py -v -s      # live Supabase + Moss
+```
+
+The integration test requires `SUPABASE_URL`, `SUPABASE_KEY`, `MOSS_PROJECT_ID`, `MOSS_PROJECT_KEY`, and `SUPABASE_TEST_TABLE` (a pre-created table with `id`, `title`, `body` columns; supabase-py can't create tables over PostgREST).

moss_connector_supabase-0.0.1/moss_connector_supabase.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+moss_connector_supabase.egg-info/PKG-INFO
+moss_connector_supabase.egg-info/SOURCES.txt
+moss_connector_supabase.egg-info/dependency_links.txt
+moss_connector_supabase.egg-info/requires.txt
+moss_connector_supabase.egg-info/top_level.txt
+src/__init__.py
+src/connector.py
+src/ingest.py
+tests/test_integration_supabase_moss.py
+tests/test_supabase.py

moss_connector_supabase-0.0.1/moss_connector_supabase.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moss_connector_supabase-0.0.1/moss_connector_supabase.egg-info/requires.txt

@@ -0,0 +1,8 @@
+moss>=1.1.1
+supabase>=2.0
+
+[dev]
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
+python-dotenv>=1.0.0
+ruff>=0.5.0

moss_connector_supabase-0.0.1/moss_connector_supabase.egg-info/top_level.txt

@@ -0,0 +1 @@
+moss_connector_supabase

moss_connector_supabase-0.0.1/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "moss-connector-supabase"
+version = "0.0.1"
+description = "Supabase source connector for moss-connectors."
+readme = "README.md"
+requires-python = ">=3.10,<3.15"
+license = { text = "BSD-2-Clause" }
+authors = [{ name = "InferEdge Inc.", email = "contact@moss.dev" }]
+keywords = ["moss", "connectors", "supabase", "postgres", "ingest", "etl"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Database",
+]
+dependencies = [
+    "moss>=1.1.1",
+    "supabase>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "python-dotenv>=1.0.0",
+    "ruff>=0.5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/usemoss/moss"
+Repository = "https://github.com/usemoss/moss"
+Source = "https://github.com/usemoss/moss/tree/main/packages/moss-data-connector/moss-connector-supabase"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+# Flat layout: src/ itself IS the package `moss_connector_supabase`.
+[tool.setuptools]
+packages = ["moss_connector_supabase"]
+package-dir = { "moss_connector_supabase" = "src" }
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "UP"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

moss_connector_supabase-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moss_connector_supabase-0.0.1/src/__init__.py

@@ -0,0 +1,4 @@
+from .connector import SupabaseConnector
+from .ingest import ingest
+
+__all__ = ["SupabaseConnector", "ingest"]

moss_connector_supabase-0.0.1/src/connector.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from typing import Any
+
+from moss import DocumentInfo
+from supabase import create_client
+
+
+class SupabaseConnector:
+    def __init__(
+        self,
+        url: str,
+        key: str,
+        table: str,
+        mapper: Callable[[dict[str, Any]], DocumentInfo],
+        select: str = "*",
+        page_size: int = 1000,
+    ) -> None:
+        self.url = url
+        self.key = key
+        self.table = table
+        self.mapper = mapper
+        self.select = select
+        self.page_size = page_size
+
+    def __iter__(self) -> Iterator[DocumentInfo]:
+        client = create_client(self.url, self.key)
+        start = 0
+        while True:
+            end = start + self.page_size - 1
+            resp = client.table(self.table).select(self.select).range(start, end).execute()
+            rows = resp.data or []
+            if not rows:
+                return
+            for row in rows:
+                yield self.mapper(row)
+            if len(rows) < self.page_size:
+                return
+            start += self.page_size

moss_connector_supabase-0.0.1/src/ingest.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import uuid
+from collections.abc import Iterable
+
+from moss import DocumentInfo, MossClient, MutationResult
+
+
+def _replace_doc_id(doc: DocumentInfo) -> DocumentInfo:
+    return DocumentInfo(
+        id=str(uuid.uuid4()),
+        text=doc.text,
+        metadata=getattr(doc, "metadata", None),
+        embedding=getattr(doc, "embedding", None),
+    )
+
+
+async def ingest(
+    source: Iterable[DocumentInfo],
+    project_id: str,
+    project_key: str,
+    index_name: str,
+    model_id: str | None = None,
+    auto_id: bool = False,
+) -> MutationResult | None:
+    if auto_id:
+        docs = [_replace_doc_id(doc) for doc in source]
+    else:
+        docs = list(source)
+    if not docs:
+        return None
+    client = MossClient(project_id, project_key)
+    return await client.create_index(index_name, docs, model_id=model_id)

moss_connector_supabase-0.0.1/tests/test_integration_supabase_moss.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import os
+import uuid
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("supabase")
+
+from moss import DocumentInfo, MossClient, QueryOptions  # noqa: E402
+from moss_connector_supabase import SupabaseConnector, ingest  # noqa: E402
+from supabase import create_client  # noqa: E402
+
+try:
+    from dotenv import load_dotenv
+
+    _here = Path(__file__).resolve()
+    for candidate in (
+        _here.parents[1] / ".env",
+        _here.parents[2] / ".env",
+        _here.parents[4] / ".env",
+    ):
+        if candidate.exists():
+            load_dotenv(candidate, override=False)
+except ImportError:
+    pass
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+PROJECT_ID = os.getenv("MOSS_PROJECT_ID")
+PROJECT_KEY = os.getenv("MOSS_PROJECT_KEY")
+PRESET_TABLE = os.getenv("SUPABASE_TEST_TABLE")
+
+pytestmark = pytest.mark.skipif(
+    not (SUPABASE_URL and SUPABASE_KEY and PROJECT_ID and PROJECT_KEY),
+    reason="Set SUPABASE_URL, SUPABASE_KEY, MOSS_PROJECT_ID, MOSS_PROJECT_KEY to run.",
+)
+
+
+_SEED_ROWS = [
+    {"id": 1, "title": "Refund policy", "body": "Refunds take 3 to 5 business days."},
+    {"id": 2, "title": "Shipping time", "body": "Orders ship within 24 hours."},
+    {"id": 3, "title": "Contact support", "body": "Reach support 24/7 via live chat."},
+    {"id": 4, "title": "Password reset", "body": "Click the link on the login page."},
+    {"id": 5, "title": "Order tracking", "body": "Tracking number sent by email."},
+]
+
+
+@pytest.fixture()
+def supabase_table():
+    """Insert seed rows into a Supabase table, clean them up after the test.
+
+    If SUPABASE_TEST_TABLE is set, use that pre-existing table and assume the
+    project does not allow ad-hoc DDL via PostgREST. Otherwise, attempt to use
+    a table named "moss_test_<uuid>" — note that supabase-py cannot create
+    tables (no DDL over PostgREST), so the user must set SUPABASE_TEST_TABLE
+    pointing at a manually-created table.
+    """
+    client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    if not PRESET_TABLE:
+        pytest.skip(
+            "Set SUPABASE_TEST_TABLE to a pre-existing table with id (int) "
+            "and body (text) columns; supabase-py cannot create tables over "
+            "PostgREST."
+        )
+
+    table_name = PRESET_TABLE
+    inserted_ids = [r["id"] for r in _SEED_ROWS]
+    try:
+        client.table(table_name).upsert(_SEED_ROWS).execute()
+        yield table_name
+    finally:
+        try:
+            client.table(table_name).delete().in_("id", inserted_ids).execute()
+        except Exception as exc:  # pragma: no cover, best-effort cleanup
+            print(f"warning: failed to clean up rows in {table_name}: {exc}")
+
+
+async def test_supabase_ingest_end_to_end(supabase_table):
+    """Full round trip: Supabase → Moss index → query → delete."""
+    table_name = supabase_table
+    client = MossClient(PROJECT_ID, PROJECT_KEY)
+
+    index_name = f"moss-supabase-e2e-{uuid.uuid4().hex[:8]}"
+
+    try:
+        connector = SupabaseConnector(
+            url=SUPABASE_URL,
+            key=SUPABASE_KEY,
+            table=table_name,
+            mapper=lambda r: DocumentInfo(
+                id=str(r["id"]),
+                text=r["body"],
+                metadata={"title": r["title"]},
+            ),
+        )
+
+        result = await ingest(connector, PROJECT_ID, PROJECT_KEY, index_name=index_name)
+        assert result is not None
+        assert result.doc_count >= 5
+
+        await client.load_index(index_name)
+        result = await client.query(index_name, "how long do refunds take", QueryOptions(top_k=3))
+
+        assert result.docs, "expected at least one document in the search result"
+        top_ids = [d.id for d in result.docs]
+        assert "1" in top_ids, f"refund-policy doc not in top 3: {top_ids}"
+
+        refund_doc = next(d for d in result.docs if d.id == "1")
+        assert refund_doc.metadata is not None
+        assert refund_doc.metadata.get("title") == "Refund policy"
+
+    finally:
+        try:
+            await client.delete_index(index_name)
+        except Exception as exc:  # pragma: no cover
+            print(f"warning: failed to delete test index {index_name}: {exc}")

moss_connector_supabase-0.0.1/tests/test_supabase.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+pytest.importorskip("supabase")
+
+from moss import DocumentInfo  # noqa: E402
+from moss_connector_supabase import SupabaseConnector, ingest  # noqa: E402
+
+
+@dataclass
+class FakeMutationResult:
+    doc_count: int
+    job_id: str = "fake-job-id"
+    index_name: str = ""
+
+
+@dataclass
+class FakeMossClient:
+    calls: list[dict[str, Any]] = field(default_factory=list)
+
+    async def create_index(self, name, docs, model_id=None):
+        docs = list(docs)
+        self.calls.append({"name": name, "docs": docs, "model_id": model_id})
+        return FakeMutationResult(doc_count=len(docs), index_name=name)
+
+
+def _supabase_mock_paginating(pages: list[list[dict[str, Any]]]) -> MagicMock:
+    """Build a mock supabase client whose
+    ``.table().select().range().execute()`` chain returns successive pages.
+
+    After all pages are exhausted, returns an empty page so the connector's
+    ``while True`` loop terminates safely even if length-based exit conditions
+    don't fire (e.g. final page exactly equals page_size).
+    """
+    responses = [MagicMock(data=p) for p in pages] + [MagicMock(data=[])]
+    range_mock = MagicMock()
+    range_mock.execute.side_effect = responses
+
+    select_mock = MagicMock()
+    select_mock.range.return_value = range_mock
+
+    table_mock = MagicMock()
+    table_mock.select.return_value = select_mock
+
+    client = MagicMock()
+    client.table.return_value = table_mock
+    return client
+
+
+async def test_supabase_ingest_end_to_end():
+    rows_from_supabase = [
+        {"id": 1, "title": "Refund policy", "body": "Refunds take 3–5 days."},
+        {"id": 2, "title": "Shipping", "body": "We ship within 24 hours."},
+        {"id": 3, "title": "Returns", "body": "Returns accepted within 30 days."},
+    ]
+    fake_client = _supabase_mock_paginating([rows_from_supabase])
+    fake_moss = FakeMossClient()
+
+    with (
+        patch(
+            "moss_connector_supabase.connector.create_client",
+            return_value=fake_client,
+        ),
+        patch(
+            "moss_connector_supabase.ingest.MossClient",
+            return_value=fake_moss,
+        ),
+    ):
+        source = SupabaseConnector(
+            url="https://x.supabase.co",
+            key="anon",
+            table="articles",
+            mapper=lambda r: DocumentInfo(
+                id=str(r["id"]),
+                text=r["body"],
+                metadata={"title": r["title"]},
+            ),
+        )
+        result = await ingest(source, "fake_id", "fake_key", index_name="articles")
+
+    assert result is not None
+    assert result.doc_count == 3
+    assert len(fake_moss.calls) == 1
+
+    moss_docs = fake_moss.calls[0]["docs"]
+    assert moss_docs[0].id == "1"
+    assert moss_docs[0].text == "Refunds take 3–5 days."
+    assert moss_docs[0].metadata == {"title": "Refund policy"}
+    assert moss_docs[2].id == "3"
+
+
+async def test_auto_id_defaults_to_false():
+    rows_from_supabase = [
+        {"id": 1, "title": "T1", "body": "B1"},
+        {"id": 2, "title": "T2", "body": "B2"},
+        {"id": 3, "title": "T3", "body": "B3"},
+    ]
+    fake_client = _supabase_mock_paginating([rows_from_supabase])
+    fake_moss = FakeMossClient()
+
+    with (
+        patch(
+            "moss_connector_supabase.connector.create_client",
+            return_value=fake_client,
+        ),
+        patch(
+            "moss_connector_supabase.ingest.MossClient",
+            return_value=fake_moss,
+        ),
+    ):
+        source = SupabaseConnector(
+            url="https://x.supabase.co",
+            key="anon",
+            table="articles",
+            mapper=lambda r: DocumentInfo(
+                id=str(r["id"]),
+                text=r["body"],
+                metadata={"title": r["title"]},
+            ),
+        )
+        await ingest(source, "fake_id", "fake_key", index_name="articles")
+
+    assert len(fake_moss.calls) == 1
+    docs = fake_moss.calls[0]["docs"]
+    assert docs[0].id == "1"
+    assert docs[1].id == "2"
+    assert docs[2].id == "3"
+
+
+async def test_auto_id_replaces_mapper_id():
+    rows_from_supabase = [
+        {"id": 1, "title": "T1", "body": "B1"},
+        {"id": 2, "title": "T2", "body": "B2"},
+        {"id": 3, "title": "T3", "body": "B3"},
+    ]
+    fake_client = _supabase_mock_paginating([rows_from_supabase])
+    fake_moss = FakeMossClient()
+
+    with (
+        patch(
+            "moss_connector_supabase.connector.create_client",
+            return_value=fake_client,
+        ),
+        patch(
+            "moss_connector_supabase.ingest.MossClient",
+            return_value=fake_moss,
+        ),
+    ):
+        source = SupabaseConnector(
+            url="https://x.supabase.co",
+            key="anon",
+            table="articles",
+            mapper=lambda r: DocumentInfo(
+                id=str(r["id"]),
+                text=r["body"],
+                metadata={"title": r["title"]},
+            ),
+        )
+        await ingest(
+            source,
+            "fake_id",
+            "fake_key",
+            index_name="articles",
+            auto_id=True,
+        )
+
+    assert len(fake_moss.calls) == 1
+    docs = fake_moss.calls[0]["docs"]
+    assert len(docs) == 3
+    original_ids = {"1", "2", "3"}
+    for doc in docs:
+        assert doc.id
+        assert uuid.UUID(doc.id)
+        assert doc.id not in original_ids
+    assert [doc.text for doc in docs] == ["B1", "B2", "B3"]
+    assert [doc.metadata for doc in docs] == [
+        {"title": "T1"},
+        {"title": "T2"},
+        {"title": "T3"},
+    ]
+
+
+async def test_pagination_advances_range_cursor():
+    """With a small page_size, the connector should request successive ranges
+    until a short page (or empty page) signals end of data."""
+    page1 = [{"id": i, "body": f"row {i}"} for i in range(2)]
+    page2 = [{"id": i, "body": f"row {i}"} for i in range(2, 3)]  # short, ends loop
+    fake_client = _supabase_mock_paginating([page1, page2])
+    fake_moss = FakeMossClient()
+
+    with (
+        patch(
+            "moss_connector_supabase.connector.create_client",
+            return_value=fake_client,
+        ),
+        patch(
+            "moss_connector_supabase.ingest.MossClient",
+            return_value=fake_moss,
+        ),
+    ):
+        source = SupabaseConnector(
+            url="https://x.supabase.co",
+            key="anon",
+            table="t",
+            mapper=lambda r: DocumentInfo(id=str(r["id"]), text=r["body"]),
+            page_size=2,
+        )
+        result = await ingest(source, "fake_id", "fake_key", "t")
+
+    assert result.doc_count == 3
+    moss_docs = fake_moss.calls[0]["docs"]
+    assert [d.id for d in moss_docs] == ["0", "1", "2"]
+
+    # Verify range() was called with advancing offsets: (0, 1), (2, 3).
+    range_calls = fake_client.table.return_value.select.return_value.range.call_args_list
+    assert range_calls[0].args == (0, 1)
+    assert range_calls[1].args == (2, 3)
+
+
+async def test_empty_result_skips_network_call():
+    fake_client = _supabase_mock_paginating([])
+    fake_moss = FakeMossClient()
+
+    with (
+        patch(
+            "moss_connector_supabase.connector.create_client",
+            return_value=fake_client,
+        ),
+        patch(
+            "moss_connector_supabase.ingest.MossClient",
+            return_value=fake_moss,
+        ),
+    ):
+        source = SupabaseConnector(
+            url="https://x.supabase.co",
+            key="anon",
+            table="empty",
+            mapper=lambda r: DocumentInfo(id=str(r["id"]), text=""),
+        )
+        result = await ingest(source, "fake_id", "fake_key", "empty")
+
+    assert result is None
+    assert fake_moss.calls == []
+
+
+async def test_select_kwarg_forwarded():
+    """The ``select`` kwarg should be passed straight through to
+    PostgREST's ``.select()``."""
+    fake_client = _supabase_mock_paginating([])
+
+    with patch(
+        "moss_connector_supabase.connector.create_client",
+        return_value=fake_client,
+    ):
+        source = SupabaseConnector(
+            url="https://x.supabase.co",
+            key="anon",
+            table="t",
+            mapper=lambda r: DocumentInfo(id="x", text="y"),
+            select="id,body,title",
+        )
+        list(source)  # exhaust to trigger the call
+
+    fake_client.table.return_value.select.assert_called_once_with("id,body,title")