@codybrom/denim 1.0.2

package/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Publish package
+        run: npx jsr publish

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Cody Bromley
+
+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.

package/deno.json

@@ -0,0 +1,9 @@
+{
+    "name": "@codybrom/denim",
+    "version": "1.0.2",
+    "description": "A Deno function that posts to Threads with text, image, or video.",
+    "entry": "./mod.ts",
+    "exports": {
+        ".": "./mod.ts"
+    }
+}

package/deno.lock

@@ -0,0 +1,26 @@
+{
+  "version": "3",
+  "packages": {
+    "specifiers": {
+      "jsr:@std/assert@1": "jsr:@std/assert@1.0.1",
+      "jsr:@std/internal@^1.0.1": "jsr:@std/internal@1.0.1"
+    },
+    "jsr": {
+      "@std/assert@1.0.1": {
+        "integrity": "13590ef8e5854f59e4ad252fd987e83239a1bf1f16cb9c69c1d123ebb807a75b",
+        "dependencies": [
+          "jsr:@std/internal@^1.0.1"
+        ]
+      },
+      "@std/internal@1.0.1": {
+        "integrity": "6f8c7544d06a11dd256c8d6ba54b11ed870aac6c5aeafff499892662c57673e6"
+      }
+    }
+  },
+  "remote": {
+    "https://deno.land/std@0.153.0/fmt/colors.ts": "ff7dc9c9f33a72bd48bc24b21bbc1b4545d8494a431f17894dbc5fe92a938fc4",
+    "https://deno.land/std@0.153.0/testing/_diff.ts": "141f978a283defc367eeee3ff7b58aa8763cf7c8e0c585132eae614468e9d7b8",
+    "https://deno.land/std@0.153.0/testing/_format.ts": "cd11136e1797791045e639e9f0f4640d5b4166148796cad37e6ef75f7d7f3832",
+    "https://deno.land/std@0.153.0/testing/asserts.ts": "d6595cfc330b4233546a047a0d7d57940771aa9d97a172ceb91e84ae6200b3af"
+  }
+}

package/examples/edge-function.ts

@@ -0,0 +1,159 @@
+// examples/edge-function.ts
+
+import {
+  type ThreadsPostRequest,
+  createThreadsContainer,
+  publishThreadsContainer,
+} from "jsr:@codybrom/denim@^1.0.2";
+
+async function postToThreads(request: ThreadsPostRequest): Promise<string> {
+  try {
+    if (request.mediaType === "VIDEO" && request.videoUrl) {
+      delete request.imageUrl;
+    }
+
+    const containerId = await createThreadsContainer(request);
+    console.log(`Container created with ID: ${containerId}`);
+
+    const publishedId = await publishThreadsContainer(
+      request.userId,
+      request.accessToken,
+      containerId
+    );
+    console.log(`Post published with ID: ${publishedId}`);
+
+    return publishedId;
+  } catch (error) {
+    console.error("Error posting to Threads:", error);
+    throw error;
+  }
+}
+
+Deno.serve(async (req: Request) => {
+  // Health check endpoint
+  if (req.method === "GET" && new URL(req.url).pathname === "/health") {
+    return new Response(JSON.stringify({ status: "ok" }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  if (req.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+
+  // Log incoming request (without sensitive data)
+  console.log(`Received ${req.method} request to ${new URL(req.url).pathname}`);
+
+  try {
+    let body;
+    try {
+      body = await req.json();
+    } catch (error) {
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: "Invalid JSON in request body",
+          details: error.message,
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    if (!body.userId || !body.accessToken || !body.mediaType) {
+      return new Response(
+        JSON.stringify({ success: false, error: "Missing required fields" }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    const postRequest: ThreadsPostRequest = {
+      userId: body.userId,
+      accessToken: body.accessToken,
+      mediaType: body.mediaType,
+      text: body.text,
+      imageUrl: body.imageUrl,
+      videoUrl: body.videoUrl,
+    };
+
+    const publishedId = await postToThreads(postRequest);
+
+    return new Response(JSON.stringify({ success: true, publishedId }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    console.error("Error processing request:", error);
+    return new Response(
+      JSON.stringify({ success: false, error: error.message }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+});
+
+/*
+  To use this example:
+  
+  1. Deploy this file to your serverless platform that supports Deno.
+  
+  2. Send POST requests to <YOUR_FUNCTION_URI> with JSON body containing:
+     - YOUR_AUTH_KEY: Your custom authorization key (if used, otherwise remove the header)
+     - userId: Your Threads user ID
+     - accessToken: Your Threads API access token
+     - mediaType: "TEXT", "IMAGE", or "VIDEO"
+     - text: The text content of your post
+     - imageUrl: URL of the image (for IMAGE posts)
+     - videoUrl: URL of the video (for VIDEO posts)
+  
+  Example curl commands:
+  
+  # Post a text-only Thread
+  curl -X POST <YOUR_FUNCTION_URI> \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer YOUR_AUTH_KEY" \
+    -d '{
+      "userId": "YOUR_USER_ID",
+      "accessToken": "YOUR_ACCESS_TOKEN",
+      "mediaType": "TEXT",
+      "text": "Hello from Denim!"
+    }'
+  
+  # Post an image Thread
+  curl -X POST <YOUR_FUNCTION_URI> \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer YOUR_AUTH_KEY" \
+    -d '{
+      "userId": "YOUR_USER_ID",
+      "accessToken": "YOUR_ACCESS_TOKEN",
+      "mediaType": "IMAGE",
+      "text": "Check out this image I posted with Denim!",
+      "imageUrl": "https://example.com/image.jpg"
+    }'
+  
+  # Post a video Thread
+  curl -X POST <YOUR_FUNCTION_URI> \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer YOUR_AUTH_KEY" \
+    -d '{
+      "userId": "YOUR_USER_ID",
+      "accessToken": "YOUR_ACCESS_TOKEN",
+      "mediaType": "VIDEO",
+      "text": "Watch this video I posted with Denim!",
+      "videoUrl": "https://example.com/video.mp4"
+    }'
+  
+  Note: If both videoUrl and imageUrl are provided in a request with mediaType "VIDEO",
+  the imageUrl will be ignored, and only the video will be posted.
+  
+  Security Note: Ensure that your function is deployed with appropriate access controls
+  and authentication mechanisms to protect sensitive data like access tokens.
+  */

package/mod.ts

@@ -0,0 +1,204 @@
+/**
+ * @module
+ *
+ * This module provides functions to interact with the Threads API,
+ * allowing users to create and publish posts on Threads.
+ */
+
+/** The base URL for the Threads API */
+export const THREADS_API_BASE_URL = "https://graph.threads.net/v1.0";
+
+/**
+ * Represents a request to post content on Threads.
+ */
+export interface ThreadsPostRequest {
+  /** The user ID of the Threads account */
+  userId: string;
+  /** The access token for authentication */
+  accessToken: string;
+  /** The type of media being posted */
+  mediaType: "TEXT" | "IMAGE" | "VIDEO";
+  /** The text content of the post (optional) */
+  text?: string;
+  /** The URL of the image to be posted (optional) */
+  imageUrl?: string;
+  /** The URL of the video to be posted (optional) */
+  videoUrl?: string;
+}
+
+/**
+ * Creates a Threads media container.
+ *
+ * @param request - The ThreadsPostRequest object containing post details
+ * @returns A Promise that resolves to the container ID
+ * @throws Will throw an error if the API request fails
+ *
+ * @example
+ * ```typescript
+ * const request: ThreadsPostRequest = {
+ *   userId: "123456",
+ *   accessToken: "your_access_token",
+ *   mediaType: "TEXT",
+ *   text: "Hello, Threads!"
+ * };
+ * const containerId = await createThreadsContainer(request);
+ * ```
+ */
+export async function createThreadsContainer(
+  request: ThreadsPostRequest
+): Promise<string> {
+  const url = `${THREADS_API_BASE_URL}/${request.userId}/threads`;
+  const body = new URLSearchParams({
+    access_token: request.accessToken,
+    media_type: request.mediaType,
+    ...(request.text && { text: request.text }),
+    ...(request.imageUrl && { image_url: request.imageUrl }),
+    ...(request.videoUrl && { video_url: request.videoUrl }),
+  });
+
+  console.log(`Sending request to: ${url}`);
+  console.log(`Request body: ${body.toString()}`);
+
+  const response = await fetch(url, {
+    method: "POST",
+    body: body,
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+  });
+
+  const responseText = await response.text();
+  console.log(`Response status: ${response.status} ${response.statusText}`);
+  console.log(`Response body: ${responseText}`);
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create Threads container: ${response.statusText}. Details: ${responseText}`
+    );
+  }
+
+  try {
+    const data = JSON.parse(responseText);
+    return data.id;
+  } catch (error) {
+    console.error(`Failed to parse response JSON: ${error}`);
+    throw new Error(`Invalid response from Threads API: ${responseText}`);
+  }
+}
+
+/**
+ * Publishes a Threads media container.
+ *
+ * @param userId - The user ID of the Threads account
+ * @param accessToken - The access token for authentication
+ * @param containerId - The ID of the container to publish
+ * @returns A Promise that resolves to the published post ID
+ * @throws Will throw an error if the API request fails
+ *
+ * @example
+ * ```typescript
+ * const publishedId = await publishThreadsContainer("123456", "your_access_token", "container_id");
+ * ```
+ */
+export async function publishThreadsContainer(
+  userId: string,
+  accessToken: string,
+  containerId: string
+): Promise<string> {
+  const url = `${THREADS_API_BASE_URL}/${userId}/threads_publish`;
+  const body = new URLSearchParams({
+    access_token: accessToken,
+    creation_id: containerId,
+  });
+
+  const response = await fetch(url, {
+    method: "POST",
+    body: body,
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+  });
+
+  const responseText = await response.text();
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to publish Threads container: ${response.statusText}. Details: ${responseText}`
+    );
+  }
+
+  try {
+    const data = JSON.parse(responseText);
+    return data.id;
+  } catch (error) {
+    console.error(`Failed to parse publish response JSON: ${error}`);
+    throw new Error(`Invalid response from Threads API: ${responseText}`);
+  }
+}
+
+/**
+ * Serves HTTP requests to create and publish Threads posts.
+ *
+ * This function sets up a server that listens for POST requests
+ * containing ThreadsPostRequest data. It creates a container and
+ * immediately publishes it.
+ *
+ * @example
+ * ```typescript
+ * // Start the server
+ * serveRequests();
+ * ```
+ */
+export function serveRequests() {
+  Deno.serve(async (req) => {
+    if (req.method !== "POST") {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+
+    try {
+      const requestData: ThreadsPostRequest = await req.json();
+      console.log(`Received request data: ${JSON.stringify(requestData)}`);
+
+      if (
+        !requestData.userId ||
+        !requestData.accessToken ||
+        !requestData.mediaType
+      ) {
+        return new Response(
+          JSON.stringify({ success: false, error: "Missing required fields" }),
+          {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+          }
+        );
+      }
+
+      // Create the Threads container
+      const containerId = await createThreadsContainer(requestData);
+
+      // Immediately attempt to publish the Threads container
+      const publishedId = await publishThreadsContainer(
+        requestData.userId,
+        requestData.accessToken,
+        containerId
+      );
+
+      return new Response(JSON.stringify({ success: true, publishedId }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    } catch (error) {
+      console.error("Error posting to Threads:", error);
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: error.message,
+          stack: error.stack,
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+  });
+}

package/mod_test.ts

@@ -0,0 +1,120 @@
+// mod_test.ts
+import {
+  assertEquals,
+  assertRejects,
+} from "https://deno.land/std@0.153.0/testing/asserts.ts";
+import {
+  createThreadsContainer,
+  publishThreadsContainer,
+  type ThreadsPostRequest,
+} from "./mod.ts";
+
+// Mock fetch response
+globalThis.fetch = (
+  input: string | URL | Request,
+  _init?: RequestInit
+): Promise<Response> => {
+  const url =
+    typeof input === "string"
+      ? input
+      : input instanceof URL
+      ? input.toString()
+      : input.url;
+
+  if (url.includes("threads_publish")) {
+    return Promise.resolve({
+      ok: true,
+      status: 200,
+      statusText: "OK",
+      text: () => Promise.resolve(JSON.stringify({ id: "published123" })),
+    } as Response);
+  } else if (url.includes("threads")) {
+    return Promise.resolve({
+      ok: true,
+      status: 200,
+      statusText: "OK",
+      text: () => Promise.resolve(JSON.stringify({ id: "container123" })),
+    } as Response);
+  }
+  return Promise.resolve({
+    ok: false,
+    status: 500,
+    statusText: "Internal Server Error",
+    text: () => Promise.resolve("Error"),
+  } as Response);
+};
+
+Deno.test("createThreadsContainer should return container ID", async () => {
+  const requestData: ThreadsPostRequest = {
+    userId: "12345",
+    accessToken: "token",
+    mediaType: "TEXT",
+    text: "Hello, Threads!",
+  };
+
+  const containerId = await createThreadsContainer(requestData);
+  assertEquals(containerId, "container123");
+});
+
+Deno.test("publishThreadsContainer should return published ID", async () => {
+  const userId = "12345";
+  const accessToken = "token";
+  const containerId = "container123";
+
+  const publishedId = await publishThreadsContainer(
+    userId,
+    accessToken,
+    containerId
+  );
+  assertEquals(publishedId, "published123");
+});
+
+Deno.test("createThreadsContainer should throw error on failure", async () => {
+  const requestData: ThreadsPostRequest = {
+    userId: "12345",
+    accessToken: "token",
+    mediaType: "TEXT",
+    text: "Hello, Threads!",
+  };
+
+  globalThis.fetch = (): Promise<Response> =>
+    Promise.resolve({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+      text: () => Promise.resolve("Error"),
+    } as Response);
+
+  await assertRejects(
+    async () => {
+      await createThreadsContainer(requestData);
+    },
+    Error,
+    "Failed to create Threads container"
+  );
+});
+
+Deno.test("publishThreadsContainer should throw error on failure", async () => {
+  const userId = "12345";
+  const accessToken = "token";
+  const containerId = "container123";
+
+  globalThis.fetch = (
+    _input: string | URL | Request,
+    _init?: RequestInit
+  ): Promise<Response> =>
+    Promise.resolve({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+      text: () => Promise.resolve("Error"),
+    } as Response);
+
+  await assertRejects(
+    async () => {
+      await publishThreadsContainer(userId, accessToken, containerId);
+    },
+    Error,
+    "Failed to publish Threads container"
+  );
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@codybrom/denim",
+  "version": "1.0.2",
+  "description": "Typescript/Deno module to simplify posting to Threads with text, images, or videos",
+  "main": "mod.ts",
+  "directories": {
+    "example": "examples"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codybrom/denim.git"
+  },
+  "keywords": [
+    "threads",
+    "threads-api"
+  ],
+  "author": "Cody Bromley",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/codybrom/denim/issues"
+  },
+  "homepage": "https://github.com/codybrom/denim#readme"
+}

package/readme.md

@@ -0,0 +1,162 @@
+# Denim
+
+[![JSR](https://jsr.io/badges/@codybrom/denim)](https://jsr.io/@codybrom/denim) [![JSR Score](https://jsr.io/badges/@codybrom/denim/score)](https://jsr.io/@codybrom/denim)
+
+**Denim** is a Deno module that provides a simple interface for posting single Threads posts using text, images, or videos.
+
+## Features
+
+- Create and publish posts on Threads
+- Support for text-only, image, and video posts
+- Easy-to-use API
+- Deployable as an edge function
+
+## Installation
+
+### Using with Deno
+
+To add Denim to your Deno project, you can use the following command:
+
+```bash
+deno add @codybrom/denim
+```
+
+This will add the latest version of Denim to your project's dependencies.
+
+## Usage
+
+To import straight from JSR, 
+
+```typescript
+import { ThreadsPostRequest, createThreadsContainer, publishThreadsContainer } from 'jsr:@codybrom/denim@^1.0.2';
+```
+
+
+### Basic Usage
+
+```typescript
+import { createThreadsContainer, publishThreadsContainer, ThreadsPostRequest } from "jsr:@codybrom/denim@^1.0.2";
+
+const request: ThreadsPostRequest = {
+  userId: "YOUR_USER_ID",
+  accessToken: "YOUR_ACCESS_TOKEN",
+  mediaType: "TEXT",
+  text: "Hello, Threads!",
+};
+
+// Create a container
+const containerId = await createThreadsContainer(request);
+
+// Publish the container
+const publishedId = await publishThreadsContainer(request.userId, request.accessToken, containerId);
+
+console.log(`Post published with ID: ${publishedId}`);
+```
+
+### Posting Different Media Types
+
+#### Text-only Post
+
+```typescript
+const textRequest: ThreadsPostRequest = {
+  userId: "YOUR_USER_ID",
+  accessToken: "YOUR_ACCESS_TOKEN",
+  mediaType: "TEXT",
+  text: "This is a text-only post on Threads!",
+};
+```
+
+#### Image Post
+
+```typescript
+const imageRequest: ThreadsPostRequest = {
+  userId: "YOUR_USER_ID",
+  accessToken: "YOUR_ACCESS_TOKEN",
+  mediaType: "IMAGE",
+  text: "Check out this image!",
+  imageUrl: "https://example.com/image.jpg",
+};
+```
+
+#### Video Post
+
+```typescript
+const videoRequest: ThreadsPostRequest = {
+  userId: "YOUR_USER_ID",
+  accessToken: "YOUR_ACCESS_TOKEN",
+  mediaType: "VIDEO",
+  text: "Watch this video!",
+  videoUrl: "https://example.com/video.mp4",
+};
+```
+
+## Deploying as an Edge Function
+
+Denim can be easily deployed as an edge function. An example implementation is provided in `examples/edge-function.ts`.
+
+To deploy:
+
+1. Copy the `examples/edge-function.ts` file to your project.
+2. Deploy this file to your serverless platform that supports Deno.
+3. Send POST requests to your function's URI with the appropriate JSON body.
+
+### Example cURL Commands
+
+```bash
+# Post a text-only Thread
+curl -X POST <YOUR_FUNCTION_URI> \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_AUTH_KEY" \
+  -d '{
+    "userId": "YOUR_USER_ID",
+    "accessToken": "YOUR_ACCESS_TOKEN",
+    "mediaType": "TEXT",
+    "text": "Hello from Denim!"
+  }'
+
+# Post an image Thread
+curl -X POST <YOUR_FUNCTION_URI> \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_AUTH_KEY" \
+  -d '{
+    "userId": "YOUR_USER_ID",
+    "accessToken": "YOUR_ACCESS_TOKEN",
+    "mediaType": "IMAGE",
+    "text": "Check out this image I posted with Denim!",
+    "imageUrl": "https://example.com/image.jpg"
+  }'
+
+# Post a video Thread
+curl -X POST <YOUR_FUNCTION_URI> \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_AUTH_KEY" \
+  -d '{
+    "userId": "YOUR_USER_ID",
+    "accessToken": "YOUR_ACCESS_TOKEN",
+    "mediaType": "VIDEO",
+    "text": "Watch this video I posted with Denim!",
+    "videoUrl": "https://example.com/video.mp4"
+  }'
+```
+
+Note: Replace with your actual authorization headers if your edge function requires them (or remove them).
+
+## Security Note
+
+Ensure that your function is deployed with appropriate access controls and authentication mechanisms to protect sensitive data like access tokens.
+
+## Testing
+
+To run the tests:
+
+```bash
+deno test mod_test.ts
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+[MIT License](LICENSE)