dex-connector-google-spreadsheet 0.1.0__tar.gz

dex_connector_google_spreadsheet-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.DS_Store
+__pycache__/
+*.py[cod]
+node_modules/
+dist/
+sdkpython/dist/dex_connectors_sdk-0.1.0-py3-none-any.whl
+/.bin/dexcli
+/.bin/dex-server-zd
+/sdkpython/.dexcli-data/
+site/.catalog.yaml
+coverage/
+*.out
+*.test
+go.work
+go.work.sum
+.idea/

dex_connector_google_spreadsheet-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Super Durable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dex_connector_google_spreadsheet-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.5
+Name: dex-connector-google-spreadsheet
+Version: 0.1.0
+Summary: Dex-native Google Sheets connector
+Project-URL: Source, https://github.com/superdurable/dex-connectors-library/tree/main/connectors/google/spreadsheet/python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: dex-connectors-sdk==0.7.0
+Requires-Dist: dex-python-sdk>=1.28.0
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# Google Sheets Python Connector
+
+This package exposes `getValues`, `findRow`, and `upsertRow` as Dex Python Steps. Install `dex-connector-google-spreadsheet==0.1.0` and create a `google-sheets-oauth` project connection. See [the connector README](../README.md) for Google Cloud OAuth setup and the append safety model.
+
+The `examples/upsert_contact` application reads or upserts a contact in a selected spreadsheet. Run its integration test with a local Dex development server; live Google authorization and provider behavior have not been verified for this port.

dex_connector_google_spreadsheet-0.1.0/README.md

@@ -0,0 +1,5 @@
+# Google Sheets Python Connector
+
+This package exposes `getValues`, `findRow`, and `upsertRow` as Dex Python Steps. Install `dex-connector-google-spreadsheet==0.1.0` and create a `google-sheets-oauth` project connection. See [the connector README](../README.md) for Google Cloud OAuth setup and the append safety model.
+
+The `examples/upsert_contact` application reads or upserts a contact in a selected spreadsheet. Run its integration test with a local Dex development server; live Google authorization and provider behavior have not been verified for this port.

dex_connector_google_spreadsheet-0.1.0/examples/upsert_contact/README.md

@@ -0,0 +1,11 @@
+# Upsert contact with Google Sheets
+
+This Flow uses the `google-sheets-contacts` project connection, reads the `email`, `name`, and `status` columns, and upserts a contact by email. Configure the Google Sheets OAuth connection in Dex Web as described in the [connector README](../../../README.md), then start a local Dex server and run `uv run python -m examples.upsert_contact.main` from `connectors/google/spreadsheet/python`.
+
+Start `GoogleSheetsUpsertContactPython` with a unique Flow ID and this JSON input:
+
+```json
+{"spreadsheetId":"your-spreadsheet-id","sheetName":"Contacts","email":"ada@example.test","name":"Ada","status":"active"}
+```
+
+Only `upserted` is wired. A conflict, provider rejection, invalid response, uncertain write, or local defect fails the Flow. `integration_test.py` verifies retry and routing through a real local Dex Worker and Client with an inert provider stand-in.

dex_connector_google_spreadsheet-0.1.0/examples/upsert_contact/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Runnable Google Sheets contact upsert Flow."""

dex_connector_google_spreadsheet-0.1.0/examples/upsert_contact/flow.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Upsert one contact through the Google Sheets connector and Dex."""
+
+from dataclasses import dataclass, field
+
+import dex
+from dex_connectors.sdk import MutationResult
+
+from dex_connectors.google_spreadsheet import Connection, UpsertRowInput, UpsertRowOutput, new_upsert_row_step
+
+CONNECTION_NAME = "google-sheets-contacts"
+FLOW_TYPE = "GoogleSheetsUpsertContactPython"
+
+
+@dataclass(frozen=True, slots=True)
+class ContactInput:
+    """Spreadsheet, tab, and contact values supplied to the Flow."""
+
+    spreadsheet_id: str = field(metadata={"dex_json_name": "spreadsheetId"})
+    sheet_name: str = field(metadata={"dex_json_name": "sheetName"})
+    email: str
+    name: str
+    status: str
+
+    def to_operation_input(self) -> UpsertRowInput:
+        """Map a contact to the stable email-key row Mutation."""
+        return UpsertRowInput(
+            self.spreadsheet_id,
+            self.sheet_name,
+            "email",
+            self.email,
+            {"email": self.email, "name": self.name, "status": self.status},
+        )
+
+
+contact_result = dex.Attribute("google-sheets-python-contact-result", UpsertRowOutput)
+
+
+# dex:group group-id:google-sheets group-label:"Google Sheets"
+# dex:explanation text:"Store the accepted contact row and complete the Flow."
+class CompleteContact(dex.Step[MutationResult[UpsertRowOutput]]):
+    """Persist the accepted row locator and complete the Flow."""
+
+    def execute(self, context: dex.Context, input: MutationResult[UpsertRowOutput]) -> dex.StepDecision:
+        """Store only the non-secret provider result."""
+        contact_result.set(context, input.value)
+        return dex.graceful_complete(input.value)
+
+
+class ContactFlow(dex.Flow[ContactInput]):
+    """Upsert a contact using one static Google Sheets connection."""
+
+    def __init__(self, connection: Connection) -> None:
+        """Bind the connector Mutation during Worker registration."""
+        if connection is None:
+            raise ValueError("Google Sheets connection is required")
+        self.complete = CompleteContact()
+        self.upsert = new_upsert_row_step(
+            step_type="UpsertContactRow",
+            step_input_type=ContactInput,
+            annotations={
+                "groupId": "google-sheets",
+                "groupLabel": "Google Sheets",
+                "explanation": "Upsert the contact in Google Sheets using email as the stable key.",
+            },
+            connection=connection,
+            connection_name=CONNECTION_NAME,
+            map_to_operation_input=ContactInput.to_operation_input,
+            upserted=self.complete,
+        )
+
+    def get_flow_type(self) -> str:
+        """Keep the Python example Flow identity stable."""
+        return FLOW_TYPE
+
+    def get_steps(self) -> dex.StepList[ContactInput]:
+        """Run the fenced provider Mutation and completion Step."""
+        return dex.StepList.start_step(self.upsert).other_steps(self.complete)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        """Register the durable contact result Attribute."""
+        return dex.PersistenceSchema.of(contact_result)

dex_connector_google_spreadsheet-0.1.0/examples/upsert_contact/integration_test.py

@@ -0,0 +1,115 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Run the contact Flow through a real Dex Worker and Client."""
+
+import asyncio
+import os
+import tempfile
+from datetime import timedelta
+from pathlib import Path
+from uuid import uuid4
+
+import dex
+import httpx
+import pytest
+from dex_connectors.sdk import ConnectionRef, SecretString, StaticCredentialProvider
+
+from dex_connectors.google_spreadsheet import Client, Config, Credentials, UpsertRowOutput, new_connection
+
+from .flow import CONNECTION_NAME, ContactFlow, ContactInput
+
+
+@pytest.mark.asyncio
+async def test_contact_upsert_retries_once_and_fails_conflict_in_real_dex() -> None:
+    """Verify durable retry, stable correlation key, and optional-branch failure."""
+    server_address = os.environ["DEX_FLOW_SERVICE_ADDRESS"]
+    writes: list[httpx.Request] = []
+    show_duplicate = False
+
+    def answer(request: httpx.Request) -> httpx.Response:
+        if request.method == "GET":
+            values = [["email", "name", "status"]]
+            if show_duplicate:
+                values.extend(
+                    [
+                        ["ada@example.test", "Ada", "active"],
+                        ["ada@example.test", "Other", "active"],
+                    ]
+                )
+            return httpx.Response(
+                200,
+                json={
+                    "range": "'Contacts'!A1:C1",
+                    "majorDimension": "ROWS",
+                    "values": values,
+                },
+            )
+        writes.append(request)
+        if len(writes) == 1:
+            return httpx.Response(503)
+        return httpx.Response(200, json={"updates": {"updatedRange": "'Contacts'!A2:C2"}})
+
+    reference = ConnectionRef("google", CONNECTION_NAME)
+    credentials = Credentials(
+        "client.apps.googleusercontent.com",
+        SecretString("secret"),
+        SecretString("inert-token"),
+        SecretString("refresh"),
+    )
+    async with httpx.AsyncClient(transport=httpx.MockTransport(answer)) as provider_transport:
+        client = Client(
+            Config(endpoint="http://127.0.0.1/v4"),
+            StaticCredentialProvider({reference: credentials}),
+            provider_transport,
+        )
+        connection = new_connection(client, reference)
+        flow = ContactFlow(connection)
+        registry = dex.Registry([flow], allow_async_handlers=True)
+        with tempfile.TemporaryDirectory(prefix="google-sheets-python-dex-") as temporary_directory:
+            cache = dex.open_blob_cache(
+                dex.BlobCacheConfig(str(Path(temporary_directory) / "blobs"), 1 << 24)
+            )
+            try:
+                worker = dex.AsyncWorker(registry, cache, dex.WorkerOptions(server_address=server_address))
+                worker_task = asyncio.create_task(worker.start())
+                try:
+                    await worker.wait_pull_registered(timeout=15)
+                    async with dex.AsyncClient(
+                        registry, cache, dex.ClientOptions(server_address=server_address)
+                    ) as dex_client:
+                        flow_id = f"sheets-python-{uuid4().hex}"
+                        await dex_client.start_flow(
+                            flow,
+                            flow_id,
+                            ContactInput("sheet-id", "Contacts", "ada@example.test", "Ada", "active"),
+                        )
+                        result = await asyncio.wait_for(
+                            dex_client.wait_for_flow(flow_id, timedelta(seconds=25)), 35
+                        )
+                        assert result.status == dex.FlowStatus.COMPLETED, result.error_message
+                        output = result.single_output(UpsertRowOutput)
+                        assert output.action == "inserted" and output.row_number == 2
+                        assert len(writes) == 2
+                        assert (
+                            writes[0].headers["X-Idempotency-Key"] == writes[1].headers["X-Idempotency-Key"]
+                        )
+                        assert writes[0].headers["X-Idempotency-Key"]
+
+                        show_duplicate = True
+                        conflict_id = f"sheets-python-{uuid4().hex}"
+                        await dex_client.start_flow(
+                            flow,
+                            conflict_id,
+                            ContactInput("sheet-id", "Contacts", "ada@example.test", "Ada", "active"),
+                        )
+                        conflict = await asyncio.wait_for(
+                            dex_client.wait_for_flow(conflict_id, timedelta(seconds=20)), 30
+                        )
+                        assert conflict.status == dex.FlowStatus.FAILED
+                        assert "conflict" in (conflict.error_message or "")
+                        assert len(writes) == 2
+                finally:
+                    await worker.stop()
+                    await worker_task
+            finally:
+                cache.close()

dex_connector_google_spreadsheet-0.1.0/examples/upsert_contact/main.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Run the Google Sheets contact Worker with project OAuth configuration."""
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.google_spreadsheet import new_project_connection
+
+from .flow import CONNECTION_NAME, ContactFlow
+
+
+async def main() -> None:
+    """Load the project connection and serve the contact Flow."""
+    project = await load_from_environment()
+    connection = new_project_connection(project, CONNECTION_NAME)
+    cache_directory = Path(
+        os.environ.get("DEX_BLOB_CACHE_DIR", str(Path(tempfile.gettempdir()) / "dex-sheets-python-blobs"))
+    )
+    cache = dex.open_blob_cache(dex.BlobCacheConfig(str(cache_directory), 1 << 30))
+    try:
+        registry = dex.Registry([ContactFlow(connection)], allow_async_handlers=True)
+        address = os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")
+        async with dex.AsyncWorker(registry, cache, dex.WorkerOptions(server_address=address)) as worker:
+            await worker.start()
+    finally:
+        cache.close()
+        await connection.aclose()
+        await project.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

dex_connector_google_spreadsheet-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dex-connector-google-spreadsheet"
+version = "0.1.0"
+description = "Dex-native Google Sheets connector"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["dex-connectors-sdk==0.7.0", "dex-python-sdk>=1.28.0", "httpx>=0.27"]
+
+[project.urls]
+Source = "https://github.com/superdurable/dex-connectors-library/tree/main/connectors/google/spreadsheet/python"
+
+[dependency-groups]
+dev = ["pytest>=8", "pytest-asyncio>=0.24", "mypy>=1.13", "ruff>=0.7", "PyYAML>=6", "types-PyYAML>=6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dex_connectors"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+mypy_path = "src"
+explicit_package_bases = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 110
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

dex_connector_google_spreadsheet-0.1.0/src/dex_connectors/google_spreadsheet/__init__.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Dex-native Google Sheets range and row operations."""
+
+from .client import Client as Client
+from .client import Config as Config
+from .client import Credentials as Credentials
+from .connection import Connection as Connection
+from .connection import new_connection as new_connection
+from .connection import new_connection_with_operations as new_connection_with_operations
+from .connection import new_project_connection as new_project_connection
+from .models import FindRowInput as FindRowInput
+from .models import FindRowOutput as FindRowOutput
+from .models import GetValuesInput as GetValuesInput
+from .models import GetValuesOutput as GetValuesOutput
+from .models import UpsertRowInput as UpsertRowInput
+from .models import UpsertRowOutput as UpsertRowOutput
+from .operations import FindRowOperation as FindRowOperation
+from .operations import GetValuesOperation as GetValuesOperation
+from .operations import UpsertRowOperation as UpsertRowOperation
+from .steps import new_find_row_step as new_find_row_step
+from .steps import new_get_values_step as new_get_values_step
+from .steps import new_upsert_row_step as new_upsert_row_step
+
+__all__ = [
+    "Client",
+    "Config",
+    "Credentials",
+    "Connection",
+    "FindRowInput",
+    "FindRowOperation",
+    "FindRowOutput",
+    "GetValuesInput",
+    "GetValuesOperation",
+    "GetValuesOutput",
+    "UpsertRowInput",
+    "UpsertRowOperation",
+    "UpsertRowOutput",
+    "new_connection",
+    "new_connection_with_operations",
+    "new_find_row_step",
+    "new_get_values_step",
+    "new_project_connection",
+    "new_upsert_row_step",
+]

dex_connector_google_spreadsheet-0.1.0/src/dex_connectors/google_spreadsheet/_generated/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT

dex_connector_google_spreadsheet-0.1.0/src/dex_connectors/google_spreadsheet/_generated/config.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from dataclasses import dataclass
+
+from dex_connectors.sdk import SecretString
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+
+    endpoint: str = "https://sheets.googleapis.com/v4"
+    max_response_bytes: int = 4194304
+    max_rows: int = 10000
+
+setattr(Config, '__module__', 'dex_connectors.google_spreadsheet.client')
+
+
+@dataclass(frozen=True, slots=True)
+class Credentials:
+
+    oauth_client_id: str
+    oauth_client_secret: SecretString
+    access_token: SecretString
+    refresh_token: SecretString
+
+setattr(Credentials, '__module__', 'dex_connectors.google_spreadsheet.client')

dex_connector_google_spreadsheet-0.1.0/src/dex_connectors/google_spreadsheet/_generated/connection.py

@@ -0,0 +1,193 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from typing import Any
+
+import httpx
+from dex_connectors.sdk import ConnectionRef, Mutation, Query, Call, SecretString, CredentialRefreshDriver
+from dex_connectors.sdk.projectconfig import ConnectionKey, LoadedProject
+from dex_connectors.sdk.projectconfig.provider import RefreshingCredentialProvider
+from dex_connectors.sdk.oauthtoken import ManifestCredentialRefreshDriver
+
+from ..client import Client, Config, Credentials
+from .definitions import CONNECTOR_ID, PROVIDER, FIND_ROW_DEFINITION, GET_VALUES_DEFINITION, UPSERT_ROW_DEFINITION
+from .refresh import AUTHORIZATION, CREDENTIAL_FIELDS
+from ..models import FindRowInput, FindRowOutput, GetValuesInput, GetValuesOutput, UpsertRowInput, UpsertRowOutput
+
+class Connection:
+
+    __slots__ = ('_get_values', '_find_row', '_upsert_row', '_client', 'reference')
+
+    def __init__(self,
+        reference: ConnectionRef,
+        get_values: Query[GetValuesInput, GetValuesOutput],
+        find_row: Query[FindRowInput, FindRowOutput],
+        upsert_row: Mutation[UpsertRowInput, UpsertRowOutput],
+        client: Client | None = None,
+    ) -> None:
+        reference.validate()
+        if reference.provider != PROVIDER or get_values is None or find_row is None or upsert_row is None:
+            raise ValueError("Google Sheets connection provider and operations are required")
+        if get_values.definition().operation != GET_VALUES_DEFINITION.operation:
+            raise ValueError("Google Sheets connection operation identity differs")
+        if find_row.definition().operation != FIND_ROW_DEFINITION.operation:
+            raise ValueError("Google Sheets connection operation identity differs")
+        if upsert_row.definition().operation != UPSERT_ROW_DEFINITION.operation:
+            raise ValueError("Google Sheets connection operation identity differs")
+        self.reference = reference
+        self._get_values = get_values
+        self._find_row = find_row
+        self._upsert_row = upsert_row
+        self._client = client
+
+    def get_values(self) -> Query[GetValuesInput, GetValuesOutput]:
+        return self._get_values
+
+    def find_row(self) -> Query[FindRowInput, FindRowOutput]:
+        return self._find_row
+
+    def upsert_row(self) -> Mutation[UpsertRowInput, UpsertRowOutput]:
+        return self._upsert_row
+
+    async def aclose(self) -> None:
+        if self._client is not None:
+            await self._client.aclose()
+
+    def __repr__(self) -> str:
+        return "google_spreadsheet.Connection([REDACTED])"
+
+    def __reduce__(self) -> tuple[object, ...]:
+        raise TypeError("Google Sheets connections cannot be serialized")
+
+setattr(Connection, '__module__', 'dex_connectors.google_spreadsheet.connection')
+
+
+def new_connection(client: Client, reference: ConnectionRef) -> Connection:
+    if client is None:
+        raise ValueError("Google Sheets client is required")
+    return Connection(reference, client.get_values(), client.find_row(), client.upsert_row(), client)
+
+setattr(new_connection, '__module__', 'dex_connectors.google_spreadsheet.connection')
+
+
+def new_connection_with_operations(
+    get_values: Query[GetValuesInput, GetValuesOutput],
+    find_row: Query[FindRowInput, FindRowOutput],
+    upsert_row: Mutation[UpsertRowInput, UpsertRowOutput],
+    reference: ConnectionRef,
+) -> Connection:
+    return Connection(reference, get_values, find_row, upsert_row)
+
+setattr(new_connection_with_operations, '__module__', 'dex_connectors.google_spreadsheet.connection')
+
+
+def decode_credentials(material: dict[str, Any], *, shared: bool = False) -> Credentials:
+    if not isinstance(material, dict):
+        raise ValueError("Google Sheets stored credential does not match the connector credential fields")
+    if set(material) - set(('oauth_client_id', 'oauth_client_secret', 'access_token', 'refresh_token')):
+        raise ValueError("Google Sheets stored credential does not match the connector credential fields")
+    is_shared = shared
+    oauth_client_id = material.get("oauth_client_id")
+    if oauth_client_id is not None and not (isinstance(oauth_client_id, str)):
+        raise ValueError("Google Sheets credential oauth_client_id has an invalid type")
+    oauth_client_secret = material.get("oauth_client_secret")
+    if oauth_client_secret is not None and not (isinstance(oauth_client_secret, str)):
+        raise ValueError("Google Sheets credential oauth_client_secret has an invalid type")
+    access_token = material.get("access_token")
+    if access_token is not None and not (isinstance(access_token, str)):
+        raise ValueError("Google Sheets credential access_token has an invalid type")
+    refresh_token = material.get("refresh_token")
+    if refresh_token is not None and not (isinstance(refresh_token, str)):
+        raise ValueError("Google Sheets credential refresh_token has an invalid type")
+    if not oauth_client_id:
+        raise ValueError("Google Sheets credential oauth_client_id is required")
+    if not oauth_client_secret and not is_shared:
+        raise ValueError("Google Sheets credential oauth_client_secret is required")
+    if not access_token:
+        raise ValueError("Google Sheets credential access_token is required")
+    if not refresh_token and not is_shared:
+        raise ValueError("Google Sheets credential refresh_token is required")
+    return Credentials(oauth_client_id, SecretString(oauth_client_secret or ''), SecretString(access_token), SecretString(refresh_token or ''))
+
+
+def decode_shared_credentials(material: dict[str, Any]) -> Credentials:
+    return decode_credentials(material, shared=True)
+
+
+def encode_credentials(credentials: Credentials) -> dict[str, Any]:
+    material: dict[str, Any] = {}
+    if credentials.oauth_client_id:
+        material["oauth_client_id"] = credentials.oauth_client_id
+    if credentials.oauth_client_secret.reveal():
+        material["oauth_client_secret"] = credentials.oauth_client_secret.reveal()
+    if credentials.access_token.reveal():
+        material["access_token"] = credentials.access_token.reveal()
+    if credentials.refresh_token.reveal():
+        material["refresh_token"] = credentials.refresh_token.reveal()
+    decode_credentials(material)
+    return material
+
+
+class _ProjectCredentialSource:
+    def __init__(self, project: LoadedProject, key: ConnectionKey, http_client: httpx.AsyncClient, settings: dict[str, Any]) -> None:
+        self.provider = RefreshingCredentialProvider(
+            project.connections, key, decode_credentials, encode_credentials, decode_shared_credentials
+        )
+        self.driver = ManifestCredentialRefreshDriver[Credentials]("Google Sheets", AUTHORIZATION, CREDENTIAL_FIELDS, http_client, settings=settings)
+
+    async def resolve(self, call: Call) -> Credentials:
+        return await self.provider.resolve_with_refresh(call, self.driver)
+
+    async def resolve_with_refresh(self, call: Call, driver: CredentialRefreshDriver[Credentials] | None = None) -> Credentials:
+        return await self.provider.resolve_with_refresh(call, driver or self.driver)
+
+    async def resolve_after_rejection(self, call: Call, driver: CredentialRefreshDriver[Credentials] | None = None) -> Credentials:
+        return await self.provider.resolve_after_rejection(call, driver or self.driver)
+
+
+def new_project_connection(
+    project: LoadedProject, connection_name: str, http_client: httpx.AsyncClient | None = None
+) -> Connection:
+    if project is None:
+        raise ValueError("Google Sheets connection requires loaded project configuration")
+    reference = ConnectionRef(PROVIDER, connection_name)
+    reference.validate()
+    key = ConnectionKey(CONNECTOR_ID, connection_name)
+    matching = [
+        entry
+        for entry in project.configuration.connections
+        if entry.connector_id == CONNECTOR_ID and entry.connection_name == connection_name
+    ]
+    if len(matching) != 1:
+        raise ValueError("Google Sheets project connection is missing or duplicated")
+    if matching[0].provider != PROVIDER:
+        raise ValueError("Google Sheets project connection provider differs")
+    config = _decode_config(matching[0].configuration)
+    http_client = http_client or httpx.AsyncClient()
+    client = Client(config, _ProjectCredentialSource(project, key, http_client, matching[0].configuration), http_client)
+    return new_connection(client, reference)
+
+setattr(new_project_connection, '__module__', 'dex_connectors.google_spreadsheet.connection')
+
+
+def _decode_config(value: dict[str, Any]) -> Config:
+    if set(value) - {"endpoint", "maxResponseBytes", "maxRows"}:
+        raise ValueError("Google Sheets configuration has unknown fields")
+    config_arguments: dict[str, Any] = {}
+    if "endpoint" in value:
+        endpoint = value["endpoint"]
+        if not (isinstance(endpoint, str)):
+            raise ValueError("Google Sheets configuration endpoint has an invalid type")
+        config_arguments['endpoint'] = endpoint
+    if "maxResponseBytes" in value:
+        max_response_bytes = value["maxResponseBytes"]
+        if not (type(max_response_bytes) is int):
+            raise ValueError("Google Sheets configuration maxResponseBytes has an invalid type")
+        config_arguments['max_response_bytes'] = max_response_bytes
+    if "maxRows" in value:
+        max_rows = value["maxRows"]
+        if not (type(max_rows) is int):
+            raise ValueError("Google Sheets configuration maxRows has an invalid type")
+        config_arguments['max_rows'] = max_rows
+    return Config(**config_arguments)