@peristyle/emdash-plugin-instagram-to-recipe 0.1.0

package/src/recipe-content.ts

@@ -0,0 +1,116 @@
+import type { ParsedInstagramRecipe } from "./instagram-recipes.js";
+
+type PortableTextBlock = {
+  _type: "block";
+  _key: string;
+  style: string;
+  listItem?: "bullet" | "number";
+  level?: number;
+  children: Array<{
+    _type: "span";
+    _key: string;
+    text: string;
+  }>;
+};
+
+function listBlocks(
+  items: string[],
+  prefix: string,
+  listItem: "bullet" | "number",
+): PortableTextBlock[] {
+  return items.map((text, index) => ({
+    _type: "block",
+    _key: `${prefix}${index}`,
+    style: "normal",
+    listItem,
+    level: 1,
+    children: [
+      {
+        _type: "span",
+        _key: `${prefix}${index}s`,
+        text,
+      },
+    ],
+  }));
+}
+
+export function recipeToPortableTextFields(recipe: ParsedInstagramRecipe): {
+  ingredients: PortableTextBlock[];
+  recipe_instructions: PortableTextBlock[];
+} {
+  const ingredients = listBlocks(recipe.ingredients, "ing", "bullet");
+
+  const recipe_instructions: PortableTextBlock[] = [
+    {
+      _type: "block",
+      _key: "ri-heading",
+      style: "h3",
+      children: [
+        {
+          _type: "span",
+          _key: "ri-heading-s",
+          text: "Instructions",
+        },
+      ],
+    },
+    ...listBlocks(recipe.instructions, "ri", "number"),
+  ];
+
+  return { ingredients, recipe_instructions };
+}
+
+export type RecipePostWriteData = {
+  title: string;
+  excerpt: string;
+  ingredients: PortableTextBlock[];
+  recipe_instructions: PortableTextBlock[];
+  featured_image?: {
+    provider?: string;
+    id: string;
+    src: string;
+    alt?: string;
+    filename?: string;
+    mimeType?: string;
+    meta?: { storageKey: string };
+  };
+  difficulty?: string;
+};
+
+export function recipeToPostWriteData(
+  recipe: ParsedInstagramRecipe,
+  featuredMedia?: RecipePostWriteData["featured_image"],
+): RecipePostWriteData {
+  const { ingredients, recipe_instructions } = recipeToPortableTextFields(recipe);
+
+  const data: RecipePostWriteData = {
+    title: recipe.title,
+    excerpt: recipe.excerpt,
+    ingredients,
+    recipe_instructions,
+    difficulty: "easy",
+  };
+
+  if (featuredMedia) {
+    data.featured_image = {
+      ...featuredMedia,
+      alt: recipe.featured_image?.alt ?? featuredMedia.alt,
+      filename: recipe.featured_image?.filename ?? featuredMedia.filename,
+    };
+  }
+
+  return data;
+}
+
+export function previewLines(recipe: ParsedInstagramRecipe): string[] {
+  const lines = [
+    `Title: ${recipe.title}`,
+    `Suggested slug: ${recipe.suggested_slug}`,
+    `Ingredients: ${recipe.ingredients.length}`,
+    `Steps: ${recipe.instructions.length}`,
+    `Source: ${recipe.source.instagram_url}`,
+  ];
+  if (recipe.featured_image) {
+    lines.push("Featured image: yes");
+  }
+  return lines;
+}

package/src/sandbox-entry.ts

@@ -0,0 +1,371 @@
+import type { PluginContext } from "emdash";
+import { z } from "astro/zod";
+
+import {
+  errorBlocks,
+  importFormBlocks,
+  previewBlocks,
+} from "./admin-blocks.js";
+import {
+  buildParsedRecipeFromPost,
+  buildParsedRecipeFromPostLenient,
+} from "./instagram-recipes.js";
+import {
+  fetchInstagramPost,
+  instagramBrowserUserAgent,
+  parseInstagramPostUrl,
+} from "./parse-instagram-post.js";
+import { recipeToPostWriteData } from "./recipe-content.js";
+
+const DEFAULT_COLLECTION = "posts";
+const PARSE_CACHE_PREFIX = "parse:";
+const IMPORT_MAP_PREFIX = "imported:";
+
+type AdminInteraction = {
+  type: string;
+  page?: string;
+  action_id?: string;
+  block_id?: string;
+  values?: Record<string, string | boolean | number>;
+  value?: unknown;
+};
+
+async function collectionSlug(ctx: PluginContext): Promise<string> {
+  return (await ctx.kv.get<string>("config:collection")) ?? DEFAULT_COLLECTION;
+}
+
+function parseCacheKey(shortcode: string): string {
+  return `${PARSE_CACHE_PREFIX}${shortcode}`;
+}
+
+function importMapKey(shortcode: string): string {
+  return `${IMPORT_MAP_PREFIX}${shortcode}`;
+}
+
+async function httpFetch(ctx: PluginContext, url: string, init?: RequestInit) {
+  if (!ctx.http) {
+    throw new Error("Network access is not available for this plugin.");
+  }
+  return ctx.http.fetch(url, init);
+}
+
+async function convertInstagramUrl(
+  ctx: PluginContext,
+  instagramUrl: string,
+): Promise<{
+  recipe: NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>;
+  existingContentId?: string;
+}> {
+  const fetchFn = (input: string, init?: RequestInit) =>
+    httpFetch(ctx, input, init);
+
+  const instagramHandle = await ctx.kv.get<string>("config:instagram_handle");
+  const post = await fetchInstagramPost(instagramUrl, fetchFn, {
+    instagramHandle: instagramHandle ?? undefined,
+  });
+  const recipe =
+    buildParsedRecipeFromPost({
+      shortcode: post.shortcode,
+      caption: post.caption,
+      displayUrl: post.displayUrl,
+      likes: 0,
+      isVideo: post.isVideo,
+      postUrl: post.postUrl,
+    }) ??
+    buildParsedRecipeFromPostLenient({
+      shortcode: post.shortcode,
+      caption: post.caption,
+      displayUrl: post.displayUrl,
+      likes: 0,
+      isVideo: post.isVideo,
+      postUrl: post.postUrl,
+    });
+
+  if (!recipe) {
+    throw new Error(
+      "Caption does not look like a recipe (needs ingredients and numbered steps). Try a post with a “What you'll need” section and numbered instructions.",
+    );
+  }
+
+  if (post.imageNotice) {
+    recipe.image_notice = post.imageNotice;
+  }
+
+  if (recipe.featured_image) {
+    const uploaded = await uploadFeaturedImageForRecipe(
+      ctx,
+      recipe,
+      post.imageBytes,
+      post.imageContentType,
+    );
+    if (uploaded) {
+      recipe.featured_image.emdash_media = uploaded;
+    } else if (recipe.featured_image.url) {
+      recipe.featured_image.upload_failed = true;
+    }
+  }
+
+  await ctx.kv.set(parseCacheKey(post.shortcode), recipe);
+
+  const existingContentId =
+    (await ctx.kv.get<string>(importMapKey(post.shortcode))) ?? undefined;
+
+  return { recipe, existingContentId };
+}
+
+type UploadedFeaturedImage = NonNullable<
+  NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>["featured_image"]
+>["emdash_media"];
+
+async function uploadFeaturedImageBytes(
+  ctx: PluginContext,
+  recipe: NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>,
+  bytes: ArrayBuffer,
+  contentType: string,
+): Promise<UploadedFeaturedImage | undefined> {
+  if (!ctx.media?.upload || !recipe.featured_image) {
+    return undefined;
+  }
+
+  const filename =
+    recipe.featured_image.filename || `${recipe.suggested_slug}.jpg`;
+
+  const uploaded = await ctx.media.upload(filename, contentType, bytes);
+
+  return {
+    provider: "local",
+    id: uploaded.mediaId,
+    src: uploaded.url,
+    mimeType: contentType,
+    meta: { storageKey: uploaded.storageKey },
+  };
+}
+
+/** Upload during convert (preferred) or re-fetch from Instagram on create draft. */
+async function uploadFeaturedImageForRecipe(
+  ctx: PluginContext,
+  recipe: NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>,
+  imageBytes?: ArrayBuffer,
+  imageContentType?: string,
+): Promise<UploadedFeaturedImage | undefined> {
+  if (!recipe.featured_image || !ctx.media?.upload) {
+    return undefined;
+  }
+
+  if (imageBytes && imageContentType) {
+    return uploadFeaturedImageBytes(
+      ctx,
+      recipe,
+      imageBytes,
+      imageContentType,
+    );
+  }
+
+  if (!recipe.featured_image.url) {
+    return undefined;
+  }
+
+  const res = await httpFetch(ctx, recipe.featured_image.url, {
+    headers: {
+      "User-Agent": instagramBrowserUserAgent,
+      Referer: recipe.source.instagram_url,
+      Accept: "image/*,*/*;q=0.8",
+    },
+  });
+
+  if (!res.ok) {
+    ctx.log.warn(`Featured image download failed: HTTP ${res.status}`);
+    return undefined;
+  }
+
+  const contentType = res.headers.get("content-type") ?? "image/jpeg";
+  if (!contentType.startsWith("image/")) {
+    ctx.log.warn(
+      `Featured image download returned non-image content-type: ${contentType}`,
+    );
+    return undefined;
+  }
+
+  return uploadFeaturedImageBytes(
+    ctx,
+    recipe,
+    await res.arrayBuffer(),
+    contentType,
+  );
+}
+
+async function createDraftFromRecipe(
+  ctx: PluginContext,
+  shortcode: string,
+): Promise<{ contentId: string; title: string; collection: string }> {
+  if (!ctx.content?.create) {
+    throw new Error("This plugin does not have permission to create content.");
+  }
+
+  const recipe = await ctx.kv.get<
+    NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>
+  >(parseCacheKey(shortcode));
+
+  if (!recipe) {
+    throw new Error(
+      "Parsed recipe expired. Convert the Instagram URL again before creating a draft.",
+    );
+  }
+
+  const collection = await collectionSlug(ctx);
+  let featuredImage = recipe.featured_image?.emdash_media;
+  if (!featuredImage && recipe.featured_image?.url) {
+    featuredImage = await uploadFeaturedImageForRecipe(ctx, recipe);
+  }
+  const data = recipeToPostWriteData(recipe, featuredImage);
+
+  const item = await ctx.content.create(collection, data);
+  await ctx.kv.set(importMapKey(shortcode), item.id);
+
+  return {
+    contentId: item.id,
+    title: recipe.title,
+    collection,
+  };
+}
+
+export default {
+  hooks: {
+    "plugin:install": {
+      handler: async (_event: unknown, ctx: PluginContext) => {
+        ctx.log.info("Instagram to Recipe plugin installed");
+        const existing = await ctx.kv.get("config:collection");
+        if (!existing) {
+          await ctx.kv.set("config:collection", DEFAULT_COLLECTION);
+        }
+      },
+    },
+  },
+
+  routes: {
+    parse: {
+      input: z.object({
+        url: z.string().min(1),
+      }),
+      handler: async (routeCtx: { input: { url: string } }, ctx: PluginContext) => {
+        const { recipe, existingContentId } = await convertInstagramUrl(
+          ctx,
+          routeCtx.input.url,
+        );
+        return { ok: true, recipe, existingContentId };
+      },
+    },
+
+    "create-draft": {
+      input: z.object({
+        shortcode: z.string().min(1),
+      }),
+      handler: async (
+        routeCtx: { input: { shortcode: string } },
+        ctx: PluginContext,
+      ) => {
+        const result = await createDraftFromRecipe(ctx, routeCtx.input.shortcode);
+        return { ok: true, ...result };
+      },
+    },
+
+    admin: {
+      handler: async (routeCtx: { input?: AdminInteraction }, ctx: PluginContext) => {
+        const interaction = routeCtx.input ?? { type: "page_load" };
+
+        if (interaction.type === "page_load") {
+          return { blocks: importFormBlocks() };
+        }
+
+        const instagramUrl = String(
+          interaction.values?.instagram_url ?? "",
+        ).trim();
+
+        if (
+          interaction.type === "form_submit" &&
+          interaction.action_id === "convert"
+        ) {
+          try {
+            if (!instagramUrl) {
+              return {
+                blocks: errorBlocks("Paste an Instagram post URL."),
+                toast: { message: "URL required", type: "error" },
+              };
+            }
+
+            parseInstagramPostUrl(instagramUrl);
+            const { recipe, existingContentId } = await convertInstagramUrl(
+              ctx,
+              instagramUrl,
+            );
+
+            return {
+              blocks: previewBlocks(recipe, { existingContentId }),
+              toast: { message: "Recipe parsed", type: "success" },
+            };
+          } catch (error) {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            return {
+              blocks: errorBlocks(message, instagramUrl),
+              toast: { message: message, type: "error" },
+            };
+          }
+        }
+
+        if (
+          (interaction.type === "block_action" ||
+            interaction.type === "button_click") &&
+          interaction.action_id === "create_draft"
+        ) {
+          const shortcode = String(interaction.value ?? "").trim();
+          if (!shortcode) {
+            return {
+              blocks: errorBlocks(
+                "Missing post reference. Convert the URL again.",
+                instagramUrl,
+              ),
+              toast: { message: "Try converting again", type: "error" },
+            };
+          }
+
+          try {
+            const { contentId, title, collection } =
+              await createDraftFromRecipe(ctx, shortcode);
+
+            const recipe = await ctx.kv.get<
+              NonNullable<ReturnType<typeof buildParsedRecipeFromPost>>
+            >(parseCacheKey(shortcode));
+
+            return {
+              blocks: recipe
+                ? [
+                    ...previewBlocks(recipe, { existingContentId: contentId }),
+                    {
+                      type: "banner",
+                      title: "Draft created",
+                      description: `“${title}” was saved to ${collection}. Open Posts in the admin to review and publish.`,
+                      variant: "default",
+                    },
+                  ]
+                : importFormBlocks(),
+              toast: {
+                message: `Draft created: ${title}`,
+                type: "success",
+              },
+            };
+          } catch (error) {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            return {
+              blocks: errorBlocks(message, instagramUrl),
+              toast: { message, type: "error" },
+            };
+          }
+        }
+
+        return { blocks: importFormBlocks(instagramUrl) };
+      },
+    },
+  },
+};