render-lab-tasks-contentful 0.1.0__tar.gz

render_lab_tasks_contentful-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+*.egg-info/
+.env
+.env.*
+!.env.example

render_lab_tasks_contentful-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Render Lab
+
+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.

render_lab_tasks_contentful-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.5
+Name: render-lab-tasks-contentful
+Version: 0.1.0
+Summary: contentful tasks for Render Workflows
+Project-URL: Repository, https://github.com/render-lab/render-tasks-python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx<0.29,>=0.28
+Requires-Dist: render-lab-tasks-core<0.2,>=0.1.1
+Requires-Dist: render-lab-triggers<0.2,>=0.1.0
+Requires-Dist: render==1.0.1
+Description-Content-Type: text/markdown
+
+# render-lab-tasks-contentful
+
+Python port of all 11 registered tasks in the pinned TypeScript pack at
+`45f9c2d44bd28e01ae9813e0d2ff56ee6c533816`. Python 3.12+.
+
+Install this distribution and its dependencies:
+
+```sh
+pip install render-lab-tasks-contentful==0.1.0
+```
+
+Import definitions from `render_lab_tasks_contentful.tasks`; combine `app` objects
+with `Workflows.from_workflows(...)`. JSON fields retain TS spelling; functions
+use snake_case. Package root imports are inert.
+
+## Tasks
+
+| Registered name | Python export (also exposes `_impl`) |
+| --- | --- |
+| `contentful.createAsset` | `create_asset` |
+| `contentful.createEntry` | `create_entry` |
+| `contentful.deleteEntry` | `delete_entry` |
+| `contentful.getAssets` | `get_assets` |
+| `contentful.getContentTypes` | `get_content_types` |
+| `contentful.getEntries` | `get_entries` |
+| `contentful.getEntry` | `get_entry` |
+| `contentful.publishAsset` | `publish_asset` |
+| `contentful.publishEntry` | `publish_entry` |
+| `contentful.unpublishEntry` | `unpublish_entry` |
+| `contentful.updateEntry` | `update_entry` |
+
+## Dependencies and retries
+
+Raw implementations accept context first and keyword-only `deps`. The `.client`
+module exports typed `Port`, `Deps`, and `Client` classes. Inject a fake port, or
+pass a caller-owned `httpx.AsyncClient` to `Client`. Default dependencies close
+their client after one operation. Credentials resolve at first use. Transport
+retries are disabled; `retry.py` owns durable policies. DTO types are in `.types`.
+Requires core >=0.1.1.
+
+## Environment
+
+| Variable | Contract |
+| --- | --- |
+| `CONTENTFUL_SPACE_ID` | Required space. |
+| `CONTENTFUL_ENVIRONMENT` | Optional environment; defaults to `master`. |
+| `CONTENTFUL_CDA_TOKEN` | Required for delivery reads: getEntries/getAssets. |
+| `CONTENTFUL_CMA_TOKEN` | Required for management reads and writes. |
+
+## Verification and limitations
+
+Delivery and management credentials are separate. DTOs flatten sys metadata and
+preserve localized fields. Versioned writes and creates disable durable retries;
+delete treats 404 as already deleted. Asset creation processes each requested
+locale and rereads its version, but does not wait for processing completion.
+Collection results at or above 4 MiB are rejected. Each read is a single page.
+
+Shared fixtures execute the actual pinned TS implementations and compare Python
+outputs and requests. Sanity's SDK calls are translated into separately asserted
+REST requests. These are hermetic checks, not real account or hosted verification.
+See [the testing backlog](https://github.com/render-lab/render-tasks-python/issues/1)
+and the root verification tracker. Licensed under MIT.
+
+## Webhook adapter
+
+`render_lab_tasks_contentful.webhooks.contentful_adapter(on_event, ...)` returns a
+registration-free adapter for `render_lab_triggers`. The callback receives the
+verified event and returns `{"task": "namespace.task", "args": [event]}` or `None`.
+The signing credential `CONTENTFUL_WEBHOOK_SECRET` is read inside verification unless
+provided explicitly. Importing this module does not register tasks. Signature
+checks use the raw body; live delivery remains in the testing backlog.

render_lab_tasks_contentful-0.1.0/README.md

@@ -0,0 +1,71 @@
+# render-lab-tasks-contentful
+
+Python port of all 11 registered tasks in the pinned TypeScript pack at
+`45f9c2d44bd28e01ae9813e0d2ff56ee6c533816`. Python 3.12+.
+
+Install this distribution and its dependencies:
+
+```sh
+pip install render-lab-tasks-contentful==0.1.0
+```
+
+Import definitions from `render_lab_tasks_contentful.tasks`; combine `app` objects
+with `Workflows.from_workflows(...)`. JSON fields retain TS spelling; functions
+use snake_case. Package root imports are inert.
+
+## Tasks
+
+| Registered name | Python export (also exposes `_impl`) |
+| --- | --- |
+| `contentful.createAsset` | `create_asset` |
+| `contentful.createEntry` | `create_entry` |
+| `contentful.deleteEntry` | `delete_entry` |
+| `contentful.getAssets` | `get_assets` |
+| `contentful.getContentTypes` | `get_content_types` |
+| `contentful.getEntries` | `get_entries` |
+| `contentful.getEntry` | `get_entry` |
+| `contentful.publishAsset` | `publish_asset` |
+| `contentful.publishEntry` | `publish_entry` |
+| `contentful.unpublishEntry` | `unpublish_entry` |
+| `contentful.updateEntry` | `update_entry` |
+
+## Dependencies and retries
+
+Raw implementations accept context first and keyword-only `deps`. The `.client`
+module exports typed `Port`, `Deps`, and `Client` classes. Inject a fake port, or
+pass a caller-owned `httpx.AsyncClient` to `Client`. Default dependencies close
+their client after one operation. Credentials resolve at first use. Transport
+retries are disabled; `retry.py` owns durable policies. DTO types are in `.types`.
+Requires core >=0.1.1.
+
+## Environment
+
+| Variable | Contract |
+| --- | --- |
+| `CONTENTFUL_SPACE_ID` | Required space. |
+| `CONTENTFUL_ENVIRONMENT` | Optional environment; defaults to `master`. |
+| `CONTENTFUL_CDA_TOKEN` | Required for delivery reads: getEntries/getAssets. |
+| `CONTENTFUL_CMA_TOKEN` | Required for management reads and writes. |
+
+## Verification and limitations
+
+Delivery and management credentials are separate. DTOs flatten sys metadata and
+preserve localized fields. Versioned writes and creates disable durable retries;
+delete treats 404 as already deleted. Asset creation processes each requested
+locale and rereads its version, but does not wait for processing completion.
+Collection results at or above 4 MiB are rejected. Each read is a single page.
+
+Shared fixtures execute the actual pinned TS implementations and compare Python
+outputs and requests. Sanity's SDK calls are translated into separately asserted
+REST requests. These are hermetic checks, not real account or hosted verification.
+See [the testing backlog](https://github.com/render-lab/render-tasks-python/issues/1)
+and the root verification tracker. Licensed under MIT.
+
+## Webhook adapter
+
+`render_lab_tasks_contentful.webhooks.contentful_adapter(on_event, ...)` returns a
+registration-free adapter for `render_lab_triggers`. The callback receives the
+verified event and returns `{"task": "namespace.task", "args": [event]}` or `None`.
+The signing credential `CONTENTFUL_WEBHOOK_SECRET` is read inside verification unless
+provided explicitly. Importing this module does not register tasks. Signature
+checks use the raw body; live delivery remains in the testing backlog.

render_lab_tasks_contentful-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "render-lab-tasks-contentful"
+version = "0.1.0"
+description = "contentful tasks for Render Workflows"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = ["render-lab-triggers>=0.1.0,<0.2", "render==1.0.1", "httpx>=0.28,<0.29", "render-lab-tasks-core>=0.1.1,<0.2"]
+
+[project.urls]
+Repository = "https://github.com/render-lab/render-tasks-python"
+
+[tool.uv.sources]
+render-lab-triggers = { workspace = true }
+render-lab-tasks-core = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/render_lab_tasks_contentful"]

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/__init__.py

@@ -0,0 +1 @@
+"""Import .tasks explicitly to register durable tasks."""

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/_app.py

@@ -0,0 +1,3 @@
+from render import Workflows
+
+app = Workflows()

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/client.py

@@ -0,0 +1,261 @@
+"""Injected vendor interface and one-attempt async HTTP adapter."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator, Mapping
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any, Protocol, cast
+
+import httpx
+from render_lab_tasks_core.bounded import assert_json_limit
+from render_lab_tasks_core.http import (
+    ApiError,
+    HttpClient,
+    enc,
+    js_string,
+    nullish,
+    required,
+)
+
+from . import types as t
+
+
+def nonempty(value: str, message: str) -> None:
+    if not value.strip():
+        raise ValueError(message)
+
+
+def obj(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def number(value: Any, default: Any = None) -> Any:
+    return value if isinstance(value, (int, float)) and not isinstance(value, bool) else default
+
+
+def document(value: Any, kind: str) -> dict[str, Any]:
+    row = obj(value)
+    sys = obj(row.get("sys"))
+    result = {
+        "id": nullish(sys.get("id"), ""),
+        "type": kind,
+        "version": nullish(sys.get("version"), nullish(sys.get("revision"), 0)),
+        "publishedVersion": number(sys.get("publishedVersion")),
+        "createdAt": sys.get("createdAt"),
+        "updatedAt": sys.get("updatedAt"),
+        "fields": obj(row.get("fields")),
+    }
+    if kind == "Entry":
+        result["contentType"] = obj(obj(sys.get("contentType")).get("sys")).get("id")
+    return result
+
+
+def content_type(value: Any) -> dict[str, Any]:
+    row = obj(value)
+    fields = row.get("fields", [])
+    return {
+        "id": nullish(obj(row.get("sys")).get("id"), ""),
+        "name": row.get("name") if isinstance(row.get("name"), str) else "",
+        "displayField": row.get("displayField")
+        if isinstance(row.get("displayField"), str)
+        else None,
+        "fields": [
+            {
+                **{
+                    k: f.get(k) if isinstance(f.get(k), str) else "" for k in ("id", "name", "type")
+                },
+                "required": f.get("required") is True,
+                "localized": f.get("localized") is True,
+            }
+            for f in map(obj, fields)
+        ]
+        if isinstance(fields, list)
+        else [],
+    }
+
+
+class Port(Protocol):
+    async def create_asset(self, input: t.CreateAssetInput) -> t.AssetDTO: ...
+    async def create_entry(self, input: t.CreateEntryInput) -> t.EntryDTO: ...
+    async def delete_entry(self, input: t.DeleteEntryInput) -> t.DeleteEntryResult: ...
+    async def get_assets(self, input: t.GetAssetsInput) -> t.AssetCollection: ...
+    async def get_content_types(self, input: t.GetContentTypesInput) -> t.ContentTypeCollection: ...
+    async def get_entries(self, input: t.GetEntriesInput) -> t.EntryCollection: ...
+    async def get_entry(self, input: t.GetEntryInput) -> t.EntryDTO: ...
+    async def publish_asset(self, input: t.PublishAssetInput) -> t.AssetDTO: ...
+    async def publish_entry(self, input: t.PublishEntryInput) -> t.EntryDTO: ...
+    async def unpublish_entry(self, input: t.UnpublishEntryInput) -> t.EntryDTO: ...
+    async def update_entry(self, input: t.UpdateEntryInput) -> t.EntryDTO: ...
+
+
+@dataclass(frozen=True)
+class Deps:
+    contentful: Port
+
+
+class Client:
+    def __init__(self, http: httpx.AsyncClient, env: Mapping[str, str] | None = None) -> None:
+        self.env = os.environ if env is None else env
+        self.http = http
+        self.cda = HttpClient(
+            http,
+            lambda: self._base("cdn.contentful.com"),
+            auth=lambda: self._auth(False),
+            label="Contentful CDA",
+        )
+        self.cma = HttpClient(
+            http,
+            lambda: self._base("api.contentful.com"),
+            auth=lambda: self._auth(True),
+            label="Contentful CMA",
+        )
+
+    def _base(self, host: str) -> str:
+        return (
+            "https://"
+            + host
+            + "/spaces/"
+            + enc(required(self.env, "CONTENTFUL_SPACE_ID"))
+            + "/environments/"
+            + enc(self.env.get("CONTENTFUL_ENVIRONMENT") or "master")
+        )
+
+    def _auth(self, management: bool) -> dict[str, str]:
+        result = {
+            "authorization": "Bearer "
+            + required(self.env, "CONTENTFUL_CMA_TOKEN" if management else "CONTENTFUL_CDA_TOKEN")
+        }
+        result["content-type" if management else "accept"] = (
+            "application/vnd.contentful.management.v1+json" if management else "application/json"
+        )
+        return result
+
+    async def _collection(
+        self, kind: str, input: Mapping[str, Any], management: bool = False
+    ) -> Any:
+        params = input.get("query", {})
+        suffix = "&".join(
+            enc(k) + "=" + enc(js_string(v)) for k, v in params.items() if v is not None
+        )
+        row = await (self.cma if management else self.cda).call(
+            "/" + kind + ("?" + suffix if suffix else "")
+        )
+        mapper = (
+            content_type
+            if kind == "content_types"
+            else lambda v: document(v, "Entry" if kind == "entries" else "Asset")
+        )
+        result = {key: number(row.get(key), 0) for key in ("total", "skip", "limit")}
+        result["items"] = (
+            [mapper(item) for item in row.get("items", [])]
+            if isinstance(row.get("items"), list)
+            else []
+        )
+        assert_json_limit("contentful." + kind, result, 4 * 1024 * 1024 - 1)
+        return result
+
+    async def get_entries(self, input: t.GetEntriesInput) -> t.EntryCollection:
+        return cast(t.EntryCollection, await self._collection("entries", input))
+
+    async def get_assets(self, input: t.GetAssetsInput) -> t.AssetCollection:
+        return cast(t.AssetCollection, await self._collection("assets", input))
+
+    async def get_content_types(self, input: t.GetContentTypesInput) -> t.ContentTypeCollection:
+        return cast(t.ContentTypeCollection, await self._collection("content_types", input, True))
+
+    async def get_entry(self, input: t.GetEntryInput) -> t.EntryDTO:
+        nonempty(input["id"], "contentful.getEntry requires a nonempty id.")
+        return cast(
+            t.EntryDTO, document(await self.cma.call("/entries/" + enc(input["id"])), "Entry")
+        )
+
+    async def create_entry(self, input: t.CreateEntryInput) -> t.EntryDTO:
+        nonempty(input["contentType"], "contentful.createEntry requires a contentType id.")
+        id = input.get("entryId")
+        row = await self.cma.call(
+            "/entries" + ("/" + enc(id) if id else ""),
+            method="PUT" if id else "POST",
+            headers={"x-contentful-content-type": input["contentType"]},
+            body={"fields": input["fields"]},
+        )
+        return cast(t.EntryDTO, document(row, "Entry"))
+
+    async def update_entry(self, input: t.UpdateEntryInput) -> t.EntryDTO:
+        nonempty(input["id"], "contentful.updateEntry requires a nonempty id.")
+        row = await self.cma.call(
+            "/entries/" + enc(input["id"]),
+            method="PUT",
+            headers={"x-contentful-version": js_string(input["version"])},
+            body={"fields": input["fields"]},
+        )
+        return cast(t.EntryDTO, document(row, "Entry"))
+
+    async def _publish(self, input: Mapping[str, Any], kind: str, method: str) -> Any:
+        nonempty(input["id"], "contentful publishing requires a nonempty id.")
+        row = await self.cma.call(
+            "/" + kind + "/" + enc(input["id"]) + "/published",
+            method=method,
+            headers={"x-contentful-version": js_string(input["version"])},
+        )
+        return document(row, "Entry" if kind == "entries" else "Asset")
+
+    async def publish_entry(self, input: t.PublishEntryInput) -> t.EntryDTO:
+        return cast(t.EntryDTO, await self._publish(input, "entries", "PUT"))
+
+    async def unpublish_entry(self, input: t.UnpublishEntryInput) -> t.EntryDTO:
+        return cast(t.EntryDTO, await self._publish(input, "entries", "DELETE"))
+
+    async def publish_asset(self, input: t.PublishAssetInput) -> t.AssetDTO:
+        return cast(t.AssetDTO, await self._publish(input, "assets", "PUT"))
+
+    async def delete_entry(self, input: t.DeleteEntryInput) -> t.DeleteEntryResult:
+        nonempty(input["id"], "contentful.deleteEntry requires a nonempty id.")
+        try:
+            await self.cma.call(
+                "/entries/" + enc(input["id"]), method="DELETE", response_type="text"
+            )
+        except ApiError as error:
+            if error.status != 404:
+                raise
+        return {"id": input["id"], "deleted": True}
+
+    async def create_asset(self, input: t.CreateAssetInput) -> t.AssetDTO:
+        file = input["fields"].get("file")
+        if not isinstance(file, dict):
+            raise ValueError(
+                "contentful.createAsset requires fields.file to be a locale-keyed object"
+            )
+        id = input.get("assetId")
+        row = await self.cma.call(
+            "/assets" + ("/" + enc(id) if id else ""),
+            method="PUT" if id else "POST",
+            body={"fields": input["fields"]},
+        )
+        for locale in input.get("processLocales", list(file)):
+            id = row["sys"]["id"]
+            await self.cma.call(
+                "/assets/" + enc(id) + "/files/" + enc(locale) + "/process",
+                method="PUT",
+                headers={"x-contentful-version": js_string(row["sys"].get("version", 0))},
+                response_type="text",
+            )
+            row = await self.cma.call("/assets/" + enc(id))
+        return cast(t.AssetDTO, document(row, "Asset"))
+
+
+@asynccontextmanager
+async def dependencies(deps: Deps | None) -> AsyncIterator[Deps]:
+    if deps is not None:
+        yield deps
+    else:
+        async with httpx.AsyncClient(
+            timeout=30, transport=httpx.AsyncHTTPTransport(retries=0)
+        ) as http:
+            yield Deps(contentful=Client(http))
+
+
+ContentfulPort = Port
+ContentfulClient = Client
+ContentfulDeps = Deps

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/create_asset.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_NO_RETRY
+from .types import AssetDTO, CreateAssetInput
+
+
+async def create_asset_impl(
+    ctx: TaskContext, input: CreateAssetInput, *, deps: Deps | None = None
+) -> AssetDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.create_asset(input)
+
+
+@app.task(name="contentful.createAsset", retry=CONTENTFUL_NO_RETRY)
+async def create_asset(ctx: TaskContext, input: CreateAssetInput) -> AssetDTO:
+    return await create_asset_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/create_entry.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_NO_RETRY
+from .types import CreateEntryInput, EntryDTO
+
+
+async def create_entry_impl(
+    ctx: TaskContext, input: CreateEntryInput, *, deps: Deps | None = None
+) -> EntryDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.create_entry(input)
+
+
+@app.task(name="contentful.createEntry", retry=CONTENTFUL_NO_RETRY)
+async def create_entry(ctx: TaskContext, input: CreateEntryInput) -> EntryDTO:
+    return await create_entry_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/delete_entry.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_RETRY
+from .types import DeleteEntryInput, DeleteEntryResult
+
+
+async def delete_entry_impl(
+    ctx: TaskContext, input: DeleteEntryInput, *, deps: Deps | None = None
+) -> DeleteEntryResult:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.delete_entry(input)
+
+
+@app.task(name="contentful.deleteEntry", retry=CONTENTFUL_RETRY)
+async def delete_entry(ctx: TaskContext, input: DeleteEntryInput) -> DeleteEntryResult:
+    return await delete_entry_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/get_assets.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_RETRY
+from .types import AssetCollection, GetAssetsInput
+
+
+async def get_assets_impl(
+    ctx: TaskContext, input: GetAssetsInput, *, deps: Deps | None = None
+) -> AssetCollection:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.get_assets(input)
+
+
+@app.task(name="contentful.getAssets", retry=CONTENTFUL_RETRY)
+async def get_assets(ctx: TaskContext, input: GetAssetsInput) -> AssetCollection:
+    return await get_assets_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/get_content_types.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_RETRY
+from .types import ContentTypeCollection, GetContentTypesInput
+
+
+async def get_content_types_impl(
+    ctx: TaskContext, input: GetContentTypesInput, *, deps: Deps | None = None
+) -> ContentTypeCollection:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.get_content_types(input)
+
+
+@app.task(name="contentful.getContentTypes", retry=CONTENTFUL_RETRY)
+async def get_content_types(ctx: TaskContext, input: GetContentTypesInput) -> ContentTypeCollection:
+    return await get_content_types_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/get_entries.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_RETRY
+from .types import EntryCollection, GetEntriesInput
+
+
+async def get_entries_impl(
+    ctx: TaskContext, input: GetEntriesInput, *, deps: Deps | None = None
+) -> EntryCollection:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.get_entries(input)
+
+
+@app.task(name="contentful.getEntries", retry=CONTENTFUL_RETRY)
+async def get_entries(ctx: TaskContext, input: GetEntriesInput) -> EntryCollection:
+    return await get_entries_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/get_entry.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_RETRY
+from .types import EntryDTO, GetEntryInput
+
+
+async def get_entry_impl(
+    ctx: TaskContext, input: GetEntryInput, *, deps: Deps | None = None
+) -> EntryDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.get_entry(input)
+
+
+@app.task(name="contentful.getEntry", retry=CONTENTFUL_RETRY)
+async def get_entry(ctx: TaskContext, input: GetEntryInput) -> EntryDTO:
+    return await get_entry_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/publish_asset.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_NO_RETRY
+from .types import AssetDTO, PublishAssetInput
+
+
+async def publish_asset_impl(
+    ctx: TaskContext, input: PublishAssetInput, *, deps: Deps | None = None
+) -> AssetDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.publish_asset(input)
+
+
+@app.task(name="contentful.publishAsset", retry=CONTENTFUL_NO_RETRY)
+async def publish_asset(ctx: TaskContext, input: PublishAssetInput) -> AssetDTO:
+    return await publish_asset_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/publish_entry.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_NO_RETRY
+from .types import EntryDTO, PublishEntryInput
+
+
+async def publish_entry_impl(
+    ctx: TaskContext, input: PublishEntryInput, *, deps: Deps | None = None
+) -> EntryDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.publish_entry(input)
+
+
+@app.task(name="contentful.publishEntry", retry=CONTENTFUL_NO_RETRY)
+async def publish_entry(ctx: TaskContext, input: PublishEntryInput) -> EntryDTO:
+    return await publish_entry_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/retry.py

@@ -0,0 +1,4 @@
+from render import Retry
+
+CONTENTFUL_NO_RETRY = Retry(max_retries=0, wait_duration_ms=0, backoff_scaling=1)
+CONTENTFUL_RETRY = Retry(max_retries=3, wait_duration_ms=1_000, backoff_scaling=2)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/tasks.py

@@ -0,0 +1,38 @@
+from ._app import app
+from .create_asset import create_asset, create_asset_impl
+from .create_entry import create_entry, create_entry_impl
+from .delete_entry import delete_entry, delete_entry_impl
+from .get_assets import get_assets, get_assets_impl
+from .get_content_types import get_content_types, get_content_types_impl
+from .get_entries import get_entries, get_entries_impl
+from .get_entry import get_entry, get_entry_impl
+from .publish_asset import publish_asset, publish_asset_impl
+from .publish_entry import publish_entry, publish_entry_impl
+from .unpublish_entry import unpublish_entry, unpublish_entry_impl
+from .update_entry import update_entry, update_entry_impl
+
+__all__ = [
+    "app",
+    "create_asset",
+    "create_asset_impl",
+    "create_entry",
+    "create_entry_impl",
+    "delete_entry",
+    "delete_entry_impl",
+    "get_assets",
+    "get_assets_impl",
+    "get_content_types",
+    "get_content_types_impl",
+    "get_entries",
+    "get_entries_impl",
+    "get_entry",
+    "get_entry_impl",
+    "publish_asset",
+    "publish_asset_impl",
+    "publish_entry",
+    "publish_entry_impl",
+    "unpublish_entry",
+    "unpublish_entry_impl",
+    "update_entry",
+    "update_entry_impl",
+]

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/types.py

@@ -0,0 +1,129 @@
+"""JSON contracts ported from the pinned TypeScript pack."""
+
+from __future__ import annotations
+
+from typing import Literal, NotRequired, TypedDict
+
+
+class ContentTypeDTOFieldsItem(TypedDict):
+    id: str
+    name: str
+    type: str
+    required: bool
+    localized: bool
+
+
+type JsonPrimitive = str | float | bool | None
+
+type JsonValue = JsonPrimitive | list[JsonValue] | dict[str, JsonValue]
+
+type JsonObject = dict[str, JsonValue]
+
+type ContentfulQuery = dict[str, str | float | bool | list[str | float]]
+
+
+class EntryDTO(TypedDict):
+    id: str
+    type: Literal["Entry"]
+    contentType: str | None
+    version: float
+    publishedVersion: float | None
+    createdAt: str | None
+    updatedAt: str | None
+    fields: JsonObject
+
+
+class AssetDTO(TypedDict):
+    id: str
+    type: Literal["Asset"]
+    version: float
+    publishedVersion: float | None
+    createdAt: str | None
+    updatedAt: str | None
+    fields: JsonObject
+
+
+class ContentTypeDTO(TypedDict):
+    id: str
+    name: str
+    displayField: str | None
+    fields: list[ContentTypeDTOFieldsItem]
+
+
+class EntryCollection(TypedDict):
+    items: list[EntryDTO]
+    total: float
+    skip: float
+    limit: float
+
+
+class AssetCollection(TypedDict):
+    items: list[AssetDTO]
+    total: float
+    skip: float
+    limit: float
+
+
+class ContentTypeCollection(TypedDict):
+    items: list[ContentTypeDTO]
+    total: float
+    skip: float
+    limit: float
+
+
+class GetEntriesInput(TypedDict):
+    query: NotRequired[ContentfulQuery]
+
+
+class GetEntryInput(TypedDict):
+    id: str
+
+
+class CreateEntryInput(TypedDict):
+    contentType: str
+    fields: JsonObject
+    entryId: NotRequired[str]
+
+
+class UpdateEntryInput(TypedDict):
+    id: str
+    version: float
+    fields: JsonObject
+
+
+class PublishEntryInput(TypedDict):
+    id: str
+    version: float
+
+
+class UnpublishEntryInput(TypedDict):
+    id: str
+    version: float
+
+
+class DeleteEntryInput(TypedDict):
+    id: str
+
+
+class GetAssetsInput(TypedDict):
+    query: NotRequired[ContentfulQuery]
+
+
+class CreateAssetInput(TypedDict):
+    fields: JsonObject
+    assetId: NotRequired[str]
+    processLocales: NotRequired[list[str]]
+
+
+class PublishAssetInput(TypedDict):
+    id: str
+    version: float
+
+
+class GetContentTypesInput(TypedDict):
+    query: NotRequired[ContentfulQuery]
+
+
+class DeleteEntryResult(TypedDict):
+    id: str
+    deleted: Literal[True]

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/unpublish_entry.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_NO_RETRY
+from .types import EntryDTO, UnpublishEntryInput
+
+
+async def unpublish_entry_impl(
+    ctx: TaskContext, input: UnpublishEntryInput, *, deps: Deps | None = None
+) -> EntryDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.unpublish_entry(input)
+
+
+@app.task(name="contentful.unpublishEntry", retry=CONTENTFUL_NO_RETRY)
+async def unpublish_entry(ctx: TaskContext, input: UnpublishEntryInput) -> EntryDTO:
+    return await unpublish_entry_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/update_entry.py

@@ -0,0 +1,18 @@
+from render import TaskContext
+
+from ._app import app
+from .client import Deps, dependencies
+from .retry import CONTENTFUL_NO_RETRY
+from .types import EntryDTO, UpdateEntryInput
+
+
+async def update_entry_impl(
+    ctx: TaskContext, input: UpdateEntryInput, *, deps: Deps | None = None
+) -> EntryDTO:
+    async with dependencies(deps) as resolved:
+        return await resolved.contentful.update_entry(input)
+
+
+@app.task(name="contentful.updateEntry", retry=CONTENTFUL_NO_RETRY)
+async def update_entry(ctx: TaskContext, input: UpdateEntryInput) -> EntryDTO:
+    return await update_entry_impl(ctx, input)

render_lab_tasks_contentful-0.1.0/src/render_lab_tasks_contentful/webhooks.py

@@ -0,0 +1,89 @@
+"""Registration-free contentful webhook verification and event mapping."""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from collections.abc import Callable
+from typing import TypedDict
+from urllib.parse import quote
+
+from render_lab_tasks_core.signatures import digest, safe_equal
+from render_lab_triggers.types import Adapter, Json, WebhookContext, WebhookDispatch, WebhookRequest
+
+type OnEvent = Callable[[dict[str, Json]], WebhookDispatch | None]
+
+
+class CanonicalRequest(TypedDict):
+    method: str
+    path: str
+    headers: dict[str, str]
+    body: str
+
+
+def compute_contentful_signature(
+    secret: str, request: CanonicalRequest, signed_header_names: list[str]
+) -> str:
+    normalized = {k.lower().strip(): v.strip() for k, v in request["headers"].items()}
+    picked = {
+        key: normalized[key]
+        for name in signed_header_names
+        if (key := name.lower().strip()) in normalized
+    }
+    picked["x-contentful-signed-headers"] = ",".join(sorted(picked))
+    headers = ";".join(f"{key}:{value}" for key, value in sorted(picked.items()))
+    parts = request["path"].split("?")
+    query = quote(parts[1], safe="~!*'()") if len(parts) > 1 and parts[1] else ""
+    path = parts[0] + ("?" + query if query else "")
+    path = quote(path, safe=";/?:@&=+$,#~!*'()-._")
+    return digest(secret, "\n".join([request["method"], path, headers, request["body"]]))
+
+
+def verify_contentful_request(
+    secret: str,
+    request: CanonicalRequest,
+    ttl_seconds: float = 30,
+    now: Callable[[], float] | None = None,
+) -> bool:
+    headers = {k.lower().strip(): v.strip() for k, v in request["headers"].items()}
+    signature = headers.get("x-contentful-signature")
+    names = [name for name in headers.get("x-contentful-signed-headers", "").split(",") if name]
+    timestamp = re.match(r"^[+-]?\d+", headers.get("x-contentful-timestamp", ""))
+    if not signature or not names or timestamp is None:
+        return False
+    now_ms = (now or (lambda: time.time() * 1000))()
+    if ttl_seconds != 0 and now_ms - int(timestamp[0]) >= ttl_seconds * 1000:
+        return False
+    return safe_equal(signature, compute_contentful_signature(secret, request, names))
+
+
+def contentful_adapter(
+    on_event: OnEvent,
+    *,
+    path: str,
+    secret: str | None = None,
+    method: str = "POST",
+    ttl_seconds: float = 30,
+    now: Callable[[], float] | None = None,
+) -> Adapter:
+    def verify(req: WebhookRequest) -> bool:
+        key = secret if secret is not None else os.getenv("CONTENTFUL_WEBHOOK_SECRET")
+        return bool(key) and verify_contentful_request(
+            key or "",
+            {"method": method, "path": path, "headers": req["headers"], "body": req["rawBody"]},
+            ttl_seconds,
+            now,
+        )
+
+    def map_event(ctx: WebhookContext) -> WebhookDispatch | None:
+        payload = ctx["body"] if ctx["body"] is not None else {}
+        headers = ctx["headers"]
+        return on_event(
+            {
+                "topic": headers.get("x-contentful-topic", headers.get("X-Contentful-Topic", "")),
+                "payload": payload,
+            }
+        )
+
+    return Adapter(verify, map_event)