astro-buffalo 0.1.2 → 0.3.0

package/README.md

@@ -3,6 +3,8 @@
 Share newly published Astro articles to Buffer using its experimental `createContentItem` API.
 One request per article, with a variant for each channel. No SDK, database, or browser JavaScript.
 
+An independent integration; not affiliated with or endorsed by Buffer.
+
 ## Setup
 
 Requires Astro 7.x and Node 24 or newer.
@@ -60,10 +62,12 @@ The endpoint must return a JSON array with these fields on each article:
 | --- | --- | --- |
 | `filePath` | Yes | Source file path relative to the Astro project root, using forward slashes; no absolute paths or `.`/`..` segments. Must match the Git path, e.g. `src/content/blog/hello.md`. |
 | `title` | Yes | Non-empty article title, also used as the default announcement. |
-| `url` | Yes | Absolute HTTP(S) canonical production URL, without whitespace, credentials, or a fragment. Must match the deployed URL without a redirect. |
+| `url` | Yes | Absolute HTTP(S) canonical production URL, without whitespace or a fragment. Must match the deployed URL without a redirect. |
 | `text` | No | Non-empty custom announcement text; the article URL is always appended. |
+| `mode` | No | `shareNow` or `addToQueue`; overrides the integration's default for this article. |
+| `channelIds` | No | Non-empty array of Buffer channel IDs; overrides the integration's selection for this article. |
 
-An empty array is valid; invalid entries stop the build before any Buffer requests.
+An empty array is valid; invalid entries or duplicate URLs stop the build before any Buffer requests.
 Adapt the collection name and routes to your site. Include only public articles, filtering drafts
 and future dates if your schema defines them:
 
@@ -103,6 +107,9 @@ mode: "addToQueue",
 `mode` supports `shareNow` (default) and `addToQueue`; both use automatic delivery.
 Disconnected or locked channels are reported and skipped.
 
+For different choices per article, return `mode` and/or `channelIds` in each manifest entry.
+Articles without these fields use the integration settings.
+
 Announcements use `title + "\n\n" + url`. Add `text: post.data.description` to an article's manifest
 entry for custom copy; the content item's title stays unchanged. Custom text is trimmed and must
 be non-empty. The URL is always appended for duplicate detection.

package/dist/git.d.ts

@@ -0,0 +1,3 @@
+export declare function findNewArticles<T extends {
+    filePath: string;
+}>(articles: T[], root: URL, contentDirectory: string): T[];

package/dist/git.js

@@ -0,0 +1,43 @@
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+function isDraft(source) {
+    const lines = (source.startsWith("\uFEFF") ? source.slice(1) : source).split("\n");
+    if (lines.length < 2 || lines[0].trimEnd() !== "---")
+        return false;
+    const end = lines.findIndex((line, index) => index > 0 && line.trimEnd() === "---");
+    if (end === -1)
+        throw new Error("Missing closing YAML frontmatter delimiter.");
+    const data = parse(lines.slice(1, end).join("\n"));
+    return typeof data === "object" && data !== null && "draft" in data && data.draft === true;
+}
+export function findNewArticles(articles, root, contentDirectory) {
+    const base = process.env.BUFFER_BASE_REF;
+    if (!base || !/^[a-f0-9]{40}$/i.test(base) || /^0+$/.test(base)) {
+        throw new Error("Set BUFFER_BASE_REF to the full commit SHA before the new posts.");
+    }
+    const git = (...args) => execFileSync("git", args, { cwd: fileURLToPath(root), encoding: "utf8" });
+    const changes = git("diff", "--name-status", "--relative", "-z", "--diff-filter=AMR", "--find-renames", base, "HEAD", "--", contentDirectory)
+        .split("\0")
+        .filter(Boolean);
+    const previousPaths = new Map();
+    for (let index = 0; index < changes.length;) {
+        const status = changes[index++];
+        const path = changes[index++];
+        if (status.startsWith("R")) {
+            previousPaths.set(changes[index++], path);
+        }
+        else {
+            previousPaths.set(path, status === "A" ? undefined : path);
+        }
+    }
+    return articles.filter(({ filePath }) => {
+        if (!previousPaths.has(filePath))
+            return false;
+        const previousPath = previousPaths.get(filePath);
+        if (previousPath && !isDraft(git("show", `${base}:./${previousPath}`))) {
+            return false;
+        }
+        return !isDraft(git("show", `HEAD:./${filePath}`));
+    });
+}

package/dist/index.js

@@ -1,10 +1,10 @@
-import { execFileSync } from "node:child_process";
 import { readFile, unlink } from "node:fs/promises";
-import timers from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import { z } from "astro/zod";
-import { parse } from "yaml";
-const articlesSchema = z.array(z.object({
+import { findNewArticles } from "./git.js";
+import { publishPosts } from "./publish.js";
+const articlesSchema = z
+    .array(z.object({
     filePath: z
         .string()
         .refine((path) => path.trim() &&
@@ -17,75 +17,31 @@ const articlesSchema = z.array(z.object({
         if (/\s/.test(value) || !URL.canParse(value))
             return false;
         const url = new URL(value);
-        return (["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.hash);
-    }, "url must be an absolute HTTP(S) URL without whitespace, credentials, or a fragment."),
+        return ["http:", "https:"].includes(url.protocol) && !url.hash;
+    }, "url must be an absolute HTTP(S) URL without whitespace or a fragment."),
     text: z
         .string({ message: "announcement text must be a non-empty string." })
         .refine((text) => text.trim(), "announcement text must be a non-empty string.")
         .optional(),
-}, { message: "must be an object." }), { message: "Buffer manifest must be an array of articles." });
-function isDraft(source) {
-    const lines = (source.startsWith("\uFEFF") ? source.slice(1) : source).split("\n");
-    if (lines.length < 2 || lines[0].trimEnd() !== "---")
-        return false;
-    const end = lines.findIndex((line, index) => index > 0 && line.trimEnd() === "---");
-    if (end === -1)
-        throw new Error("Missing closing YAML frontmatter delimiter.");
-    const data = parse(lines.slice(1, end).join("\n"));
-    return typeof data === "object" && data !== null && "draft" in data && data.draft === true;
-}
-async function waitForDeployment(url, logger) {
-    const deadline = Date.now() + 300_000;
-    while (Date.now() < deadline) {
-        let response;
-        try {
-            response = await fetch(url, {
-                method: "HEAD",
-                signal: AbortSignal.timeout(10_000),
+    mode: z.enum(["shareNow", "addToQueue"]).optional(),
+    channelIds: z
+        .array(z.string().refine((id) => id.trim(), "channel ID must be non-empty."))
+        .min(1)
+        .optional(),
+}, { message: "must be an object." }), { message: "Buffer manifest must be an array of articles." })
+    .superRefine((articles, context) => {
+    const urls = new Set();
+    for (const [index, { url }] of articles.entries()) {
+        if (urls.has(url)) {
+            context.addIssue({
+                code: "custom",
+                path: [index, "url"],
+                message: `Duplicate article URL: ${url}.`,
             });
         }
-        catch (error) {
-            if (!(error instanceof TypeError) &&
-                !(error instanceof Error && error.name === "TimeoutError")) {
-                throw error;
-            }
-            logger.warn(`Cannot reach ${url}: ${error.message}. Retrying.`);
-        }
-        if (response) {
-            if (response.ok && response.url === url)
-                return;
-            if (![404, 502, 503, 504].includes(response.status)) {
-                throw new Error(`Cannot verify ${url}: HTTP ${response.status}.`);
-            }
-        }
-        logger.info(`Waiting for ${url} to be deployed...`);
-        await timers.setTimeout(10_000);
-    }
-    throw new Error(`${url} is not live yet. Rerun after deployment succeeds.`);
-}
-async function request(token, query, variables) {
-    const response = await fetch("https://api.buffer.com", {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ query, variables }),
-        signal: AbortSignal.timeout(30_000),
-    });
-    if (!response.ok) {
-        const retryAfter = response.headers.get("Retry-After");
-        throw new Error(`Buffer request failed: HTTP ${response.status}.${retryAfter ? ` Retry after ${retryAfter} seconds.` : ""}`);
-    }
-    const result = await response.json();
-    if (result.errors?.length) {
-        throw new Error(`Buffer: ${result.errors.map((error) => error.message).join("; ")}`);
+        urls.add(url);
     }
-    if (!result.data) {
-        throw new Error("Buffer returned no data.");
-    }
-    return result.data;
-}
+});
 export default function buffer({ posts: entrypoint, contentDirectory, channelIds, mode = "shareNow", }) {
     if (mode !== "shareNow" && mode !== "addToQueue") {
         throw new Error('mode must be "shareNow" or "addToQueue".');
@@ -131,152 +87,16 @@ export default function buffer({ posts: entrypoint, contentDirectory, channelIds
                         .join("\n"));
                 }
                 const articles = result.data;
-                const base = process.env.BUFFER_BASE_REF;
-                if (!base || !/^[a-f0-9]{40}$/i.test(base) || /^0+$/.test(base)) {
-                    throw new Error("Set BUFFER_BASE_REF to the full commit SHA before the new posts.");
-                }
-                const git = (...args) => execFileSync("git", args, { cwd: fileURLToPath(root), encoding: "utf8" });
-                const changes = git("diff", "--name-status", "--relative", "-z", "--diff-filter=AMR", "--find-renames", base, "HEAD", "--", contentDirectory)
-                    .split("\0")
-                    .filter(Boolean);
-                const previousPaths = new Map();
-                for (let index = 0; index < changes.length;) {
-                    const status = changes[index++];
-                    const path = changes[index++];
-                    if (status.startsWith("R")) {
-                        previousPaths.set(changes[index++], path);
-                    }
-                    else {
-                        previousPaths.set(path, status === "A" ? undefined : path);
-                    }
-                }
-                const posts = articles
-                    .filter(({ filePath }) => {
-                    if (!previousPaths.has(filePath))
-                        return false;
-                    const previousPath = previousPaths.get(filePath);
-                    if (previousPath && !isDraft(git("show", `${base}:./${previousPath}`))) {
-                        return false;
-                    }
-                    return !isDraft(git("show", `HEAD:./${filePath}`));
-                })
-                    .map((article) => ({
+                const posts = findNewArticles(articles, root, contentDirectory).map((article) => ({
                     ...article,
                     text: `${article.text?.trim() ?? article.title}\n\n${article.url}`,
+                    mode: article.mode ?? mode,
                 }));
                 if (!posts.length) {
                     logger.info("No new blog posts to share.");
                     return;
                 }
-                const token = process.env.BUFFER_API_KEY;
-                const organizationId = process.env.BUFFER_ORGANIZATION_ID;
-                if (!token || !organizationId) {
-                    throw new Error("Set BUFFER_API_KEY and BUFFER_ORGANIZATION_ID before publishing.");
-                }
-                const { channels } = await request(token, `query Channels($input: ChannelsInput!) {
-            channels(input: $input) { id name isDisconnected isLocked }
-          }`, { input: { organizationId } });
-                if (channelIds) {
-                    const unknown = channelIds.filter((id) => !channels.some((channel) => channel.id === id));
-                    if (unknown.length) {
-                        throw new Error(`Unknown Buffer channel IDs: ${unknown.join(", ")}.`);
-                    }
-                }
-                const connected = channels.filter((channel) => {
-                    if (channelIds && !channelIds.includes(channel.id))
-                        return false;
-                    if (channel.isDisconnected || channel.isLocked) {
-                        logger.warn(`Cannot publish to "${channel.name}": disconnected or locked in Buffer.`);
-                        return false;
-                    }
-                    return true;
-                });
-                if (!connected.length) {
-                    throw new Error("No connected, unlocked Buffer channels found.");
-                }
-                const existing = [];
-                let after = null;
-                do {
-                    const { posts: page } = await request(token, `query Posts($input: PostsInput!, $after: String) {
-              posts(input: $input, first: 100, after: $after) {
-                edges { node { id text channelId status } }
-                pageInfo { hasNextPage endCursor }
-              }
-            }`, {
-                        input: { organizationId, filter: { channelIds: connected.map(({ id }) => id) } },
-                        after,
-                    });
-                    if (!page.edges) {
-                        throw new Error("Buffer returned no post history.");
-                    }
-                    existing.push(...page.edges.map(({ node }) => node));
-                    if (page.pageInfo.hasNextPage &&
-                        (!page.pageInfo.endCursor || page.pageInfo.endCursor === after)) {
-                        throw new Error("Buffer returned an invalid pagination cursor.");
-                    }
-                    after = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
-                } while (after);
-                const failures = [];
-                for (const article of posts) {
-                    const pending = [];
-                    for (const channel of connected) {
-                        const shared = existing.find((post) => post.channelId === channel.id && post.text.split(/\s+/).includes(article.url));
-                        if (shared) {
-                            if (!["sent", "scheduled", "sending"].includes(shared.status)) {
-                                failures.push(new Error(`Review Buffer post ${shared.id} for "${channel.name}": ${shared.status}.`));
-                            }
-                            logger.info(`Already in Buffer: "${article.title}" -> "${channel.name}".`);
-                            continue;
-                        }
-                        pending.push(channel);
-                    }
-                    if (!pending.length)
-                        continue;
-                    if (dryRun) {
-                        logger.info(`Dry run: ${JSON.stringify({
-                            title: article.title,
-                            text: article.text,
-                            channels: pending.map(({ id, name }) => ({ id, name })),
-                            mode,
-                        })}`);
-                        continue;
-                    }
-                    await waitForDeployment(article.url, logger);
-                    const { createContentItem } = await request(token, `mutation Publish($input: CreateContentItemInput!) {
-              createContentItem(input: $input) {
-                ... on CreateContentItemSuccess { content { id } }
-                ... on CreateContentItemFailure {
-                  message
-                  errors { ... on MutationError { message } }
-                }
-              }
-            }`, {
-                        input: {
-                            organizationId,
-                            title: article.title,
-                            posts: pending.map(({ id }) => ({
-                                channelId: id,
-                                text: article.text,
-                                schedulingType: "automatic",
-                                mode,
-                            })),
-                        },
-                    });
-                    if (!createContentItem.content?.id) {
-                        failures.push(new Error(`"${article.title}": ${[
-                            createContentItem.message ?? "No content item ID returned.",
-                            ...(createContentItem.errors ?? []).map(({ message }) => message),
-                        ].join("; ")}`));
-                        continue;
-                    }
-                    logger.info(`Submitted "${article.title}" to ${pending.length} channels (${createContentItem.content.id}).`);
-                }
-                if (failures.length) {
-                    throw new AggregateError(failures, [
-                        "Some Buffer posts need attention; reruns skip existing posts.",
-                        ...failures.map((error) => error.message),
-                    ].join("\n"));
-                }
+                await publishPosts(posts, { channelIds, dryRun, logger });
             },
         },
     };

package/dist/publish.d.ts

@@ -0,0 +1,14 @@
+import type { AstroIntegrationLogger } from "astro";
+interface Article {
+    title: string;
+    url: string;
+    text: string;
+    mode: "shareNow" | "addToQueue";
+    channelIds?: string[];
+}
+export declare function publishPosts(posts: Article[], { channelIds, dryRun, logger, }: {
+    channelIds?: string[];
+    dryRun: boolean;
+    logger: AstroIntegrationLogger;
+}): Promise<void>;
+export {};

package/dist/publish.js

@@ -0,0 +1,175 @@
+import timers from "node:timers/promises";
+async function waitForDeployment(url, logger) {
+    const deadline = Date.now() + 300_000;
+    while (Date.now() < deadline) {
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "HEAD",
+                signal: AbortSignal.timeout(10_000),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof TypeError) &&
+                !(error instanceof Error && error.name === "TimeoutError")) {
+                throw error;
+            }
+            logger.warn(`Cannot reach ${url}: ${error.message}. Retrying.`);
+        }
+        if (response) {
+            if (response.ok && response.url === url)
+                return;
+            if (![404, 502, 503, 504].includes(response.status)) {
+                throw new Error(`Cannot verify ${url}: HTTP ${response.status}.`);
+            }
+        }
+        logger.info(`Waiting for ${url} to be deployed...`);
+        await timers.setTimeout(10_000);
+    }
+    throw new Error(`${url} is not live yet. Rerun after deployment succeeds.`);
+}
+async function request(token, query, variables) {
+    const response = await fetch("https://api.buffer.com", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ query, variables }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok) {
+        const retryAfter = response.headers.get("Retry-After");
+        throw new Error(`Buffer request failed: HTTP ${response.status}.${retryAfter ? ` Retry after ${retryAfter} seconds.` : ""}`);
+    }
+    const result = await response.json();
+    if (result.errors?.length) {
+        throw new Error(`Buffer: ${result.errors.map((error) => error.message).join("; ")}`);
+    }
+    if (!result.data) {
+        throw new Error("Buffer returned no data.");
+    }
+    return result.data;
+}
+export async function publishPosts(posts, { channelIds, dryRun, logger, }) {
+    const token = process.env.BUFFER_API_KEY;
+    const organizationId = process.env.BUFFER_ORGANIZATION_ID;
+    if (!token || !organizationId) {
+        throw new Error("Set BUFFER_API_KEY and BUFFER_ORGANIZATION_ID before publishing.");
+    }
+    const { channels } = await request(token, `query Channels($input: ChannelsInput!) {
+      channels(input: $input) { id name isDisconnected isLocked }
+    }`, { input: { organizationId } });
+    const selections = posts.map((article) => ({
+        article,
+        ids: article.channelIds ?? channelIds,
+    }));
+    const unknown = [
+        ...new Set(selections.flatMap(({ ids }) => ids?.filter((id) => !channels.some((channel) => channel.id === id)) ?? [])),
+    ];
+    if (unknown.length) {
+        throw new Error(`Unknown Buffer channel IDs: ${unknown.join(", ")}.`);
+    }
+    const connected = channels.filter((channel) => {
+        if (!selections.some(({ ids }) => !ids || ids.includes(channel.id)))
+            return false;
+        if (channel.isDisconnected || channel.isLocked) {
+            logger.warn(`Cannot publish to "${channel.name}": disconnected or locked in Buffer.`);
+            return false;
+        }
+        return true;
+    });
+    if (!connected.length) {
+        throw new Error("No connected, unlocked Buffer channels found.");
+    }
+    const postChannels = selections.map(({ article, ids }) => {
+        const selected = connected.filter((channel) => !ids || ids.includes(channel.id));
+        if (!selected.length) {
+            throw new Error(`No connected, unlocked Buffer channels found for "${article.title}".`);
+        }
+        return { article, channels: selected };
+    });
+    const existing = [];
+    let after = null;
+    do {
+        const { posts: page } = await request(token, `query Posts($input: PostsInput!, $after: String) {
+        posts(input: $input, first: 100, after: $after) {
+          edges { node { id text channelId status } }
+          pageInfo { hasNextPage endCursor }
+        }
+      }`, {
+            input: { organizationId, filter: { channelIds: connected.map(({ id }) => id) } },
+            after,
+        });
+        if (!page.edges) {
+            throw new Error("Buffer returned no post history.");
+        }
+        existing.push(...page.edges.map(({ node }) => node));
+        if (page.pageInfo.hasNextPage &&
+            (!page.pageInfo.endCursor || page.pageInfo.endCursor === after)) {
+            throw new Error("Buffer returned an invalid pagination cursor.");
+        }
+        after = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
+    } while (after);
+    const failures = [];
+    for (const { article, channels } of postChannels) {
+        const pending = [];
+        for (const channel of channels) {
+            const shared = existing.find((post) => post.channelId === channel.id && post.text.split(/\s+/).includes(article.url));
+            if (shared) {
+                if (!["sent", "scheduled", "sending"].includes(shared.status)) {
+                    failures.push(new Error(`Review Buffer post ${shared.id} for "${channel.name}": ${shared.status}.`));
+                }
+                logger.info(`Already in Buffer: "${article.title}" -> "${channel.name}".`);
+                continue;
+            }
+            pending.push(channel);
+        }
+        if (!pending.length)
+            continue;
+        if (dryRun) {
+            logger.info(`Dry run: ${JSON.stringify({
+                title: article.title,
+                text: article.text,
+                channels: pending.map(({ id, name }) => ({ id, name })),
+                mode: article.mode,
+            })}`);
+            continue;
+        }
+        await waitForDeployment(article.url, logger);
+        const { createContentItem } = await request(token, `mutation Publish($input: CreateContentItemInput!) {
+        createContentItem(input: $input) {
+          ... on CreateContentItemSuccess { content { id } }
+          ... on CreateContentItemFailure {
+            message
+            errors { ... on MutationError { message } }
+          }
+        }
+      }`, {
+            input: {
+                organizationId,
+                title: article.title,
+                posts: pending.map(({ id }) => ({
+                    channelId: id,
+                    text: article.text,
+                    schedulingType: "automatic",
+                    mode: article.mode,
+                })),
+            },
+        });
+        if (!createContentItem.content?.id) {
+            failures.push(new Error(`"${article.title}": ${[
+                createContentItem.message ?? "No content item ID returned.",
+                ...(createContentItem.errors ?? []).map(({ message }) => message),
+            ].join("; ")}`));
+            continue;
+        }
+        logger.info(`Submitted "${article.title}" to ${pending.length} channels (${createContentItem.content.id}).`);
+    }
+    if (failures.length) {
+        throw new AggregateError(failures, [
+            "Some Buffer posts need attention; reruns skip existing posts.",
+            ...failures.map((error) => error.message),
+        ].join("\n"));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-buffalo",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Share newly published Astro articles through Buffer.",
   "license": "MIT",
   "homepage": "https://github.com/HiroAgustin/astro-buffalo#readme",