@codybrom/denim 1.3.5 → 2.0.0

package/src/utils/validateRequest.ts

@@ -0,0 +1,166 @@
+import type { ThreadsPostRequest } from "../types.ts";
+/**
+ * Validates the ThreadsPostRequest object to ensure correct usage of media-specific properties.
+ *
+ * @param request - The ThreadsPostRequest object to validate
+ * @throws Will throw an error if the request contains invalid combinations of media type and properties
+ *
+ * @example
+ * ```typescript
+ * const request: ThreadsPostRequest = {
+ *   userId: "123456",
+ *   accessToken: "your_access_token",
+ *   mediaType: "IMAGE",
+ *   imageUrl: "https://example.com/image.jpg"
+ * };
+ * await validateRequest(request); // This will not throw an error
+ * ```
+ */
+export async function validateRequest(
+	request: ThreadsPostRequest,
+): Promise<void> {
+	// Check for invalid combinations first
+	if (request.mediaType !== "IMAGE" && request.imageUrl) {
+		throw new Error("imageUrl can only be used with IMAGE media type");
+	}
+	if (request.mediaType !== "VIDEO" && request.videoUrl) {
+		throw new Error("videoUrl can only be used with VIDEO media type");
+	}
+	if (request.mediaType !== "TEXT" && request.linkAttachment) {
+		throw new Error("linkAttachment can only be used with TEXT media type");
+	}
+	if (request.mediaType !== "CAROUSEL" && request.children) {
+		throw new Error("children can only be used with CAROUSEL media type");
+	}
+
+	// Poll attachment can only be used with TEXT posts
+	if (request.pollAttachment && request.mediaType !== "TEXT") {
+		throw new Error("pollAttachment can only be used with TEXT media type");
+	}
+
+	// GIF attachment can only be used with TEXT posts
+	if (request.gifAttachment && request.mediaType !== "TEXT") {
+		throw new Error("gifAttachment can only be used with TEXT media type");
+	}
+
+	// Ghost posts can only be TEXT and cannot be replies
+	if (request.isGhostPost) {
+		if (request.mediaType !== "TEXT") {
+			throw new Error("isGhostPost can only be used with TEXT media type");
+		}
+		if (request.replyToId) {
+			throw new Error("isGhostPost cannot be used together with replyToId");
+		}
+	}
+
+	// Text attachment can only be used with TEXT posts and not with polls
+	if (request.textAttachment) {
+		if (request.mediaType !== "TEXT") {
+			throw new Error("textAttachment can only be used with TEXT media type");
+		}
+		if (request.pollAttachment) {
+			throw new Error(
+				"textAttachment cannot be used together with pollAttachment",
+			);
+		}
+	}
+
+	// Text entities limited to 10
+	if (request.textEntities && request.textEntities.length > 10) {
+		throw new Error("textEntities cannot have more than 10 entries");
+	}
+
+	// If combinations are valid, do media-specific validations
+	if (request.mediaType === "IMAGE" && request.imageUrl) {
+		await validateImageSpecs(request.imageUrl);
+	}
+	if (request.mediaType === "VIDEO" && request.videoUrl) {
+		await validateVideoSpecs(request.videoUrl);
+	}
+	if (request.mediaType === "TEXT" && request.linkAttachment) {
+		validateLinkUrl(request.linkAttachment);
+	}
+	if (
+		request.mediaType === "CAROUSEL" &&
+		(!request.children || request.children.length < 2)
+	) {
+		throw new Error("CAROUSEL media type requires at least 2 children");
+	}
+}
+
+async function validateImageSpecs(imageUrl: string): Promise<void> {
+	let response: Response;
+	try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 5000);
+		response = await fetch(imageUrl, {
+			method: "HEAD",
+			signal: controller.signal,
+		});
+		clearTimeout(timeoutId);
+	} catch (_error) {
+		// HEAD not supported or network error — skip validation
+		return;
+	}
+
+	if (response.status === 405) return;
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch image: ${response.statusText}`);
+	}
+
+	const contentType = response.headers.get("content-type")?.split(";")[0]
+		.trim();
+	if (!contentType || !["image/jpeg", "image/png"].includes(contentType)) {
+		throw new Error("Image format must be JPEG or PNG");
+	}
+
+	const contentLength = response.headers.get("content-length");
+	if (contentLength && parseInt(contentLength, 10) > 8 * 1024 * 1024) {
+		throw new Error("Image file size must not exceed 8 MB");
+	}
+}
+
+async function validateVideoSpecs(videoUrl: string): Promise<void> {
+	let response: Response;
+	try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 5000);
+		response = await fetch(videoUrl, {
+			method: "HEAD",
+			signal: controller.signal,
+		});
+		clearTimeout(timeoutId);
+	} catch (_error) {
+		// HEAD not supported or network error — skip validation
+		return;
+	}
+
+	if (response.status === 405) return;
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch video: ${response.statusText}`);
+	}
+
+	const contentType = response.headers.get("content-type")?.split(";")[0]
+		.trim();
+	if (!contentType || !["video/quicktime", "video/mp4"].includes(contentType)) {
+		throw new Error("Video format must be MOV or MP4");
+	}
+
+	const contentLength = response.headers.get("content-length");
+	if (contentLength && parseInt(contentLength, 10) > 1024 * 1024 * 1024) {
+		throw new Error("Video file size must not exceed 1 GB");
+	}
+}
+
+function validateLinkUrl(url: string): void {
+	// Pattern to ensure URL starts with http:// or https:// and has a valid domain
+	const urlPattern = /^https?:\/\/[\w.-]+\.[a-zA-Z]{2,}/;
+
+	if (!urlPattern.test(url)) {
+		throw new Error(
+			"Invalid URL format for linkAttachment. URL must start with http:// or https:// and contain a valid domain",
+		);
+	}
+}

package/mock_threads_api.ts

@@ -1,174 +0,0 @@
-// mock_threads_api.ts
-
-import type {
-  ThreadsContainer,
-  ThreadsPost,
-  ThreadsProfile,
-  PublishingLimit,
-  ThreadsPostRequest,
-  ThreadsListResponse,
-} from "./types.ts";
-
-export class MockThreadsAPI implements MockThreadsAPI {
-  private containers: Map<string, ThreadsContainer> = new Map();
-  private posts: Map<string, ThreadsPost> = new Map();
-  private users: Map<string, ThreadsProfile> = new Map();
-  private publishingLimits: Map<string, PublishingLimit> = new Map();
-  private errorMode = false;
-
-  constructor() {
-    // Initialize with some sample data
-    this.users.set("12345", {
-      id: "12345",
-      username: "testuser",
-      name: "Test User",
-      threadsProfilePictureUrl: "https://example.com/profile.jpg",
-      threadsBiography: "This is a test user",
-    });
-
-    this.publishingLimits.set("12345", {
-      quota_usage: 10,
-      config: {
-        quota_total: 250,
-        quota_duration: 86400,
-      },
-    });
-  }
-
-  setErrorMode(mode: boolean) {
-    this.errorMode = mode;
-  }
-
-  createThreadsContainer(
-    request: ThreadsPostRequest
-  ): Promise<string | { id: string; permalink: string }> {
-    if (this.errorMode) {
-      return Promise.reject(new Error("Failed to create Threads container"));
-    }
-    const containerId = `container_${Math.random().toString(36).substring(7)}`;
-    const permalink = `https://www.threads.net/@${request.userId}/post/${containerId}`;
-    const container: ThreadsContainer = {
-      id: containerId,
-      permalink,
-      status: "FINISHED",
-    };
-    this.containers.set(containerId, container);
-
-    // Create a post immediately when creating a container
-    const postId = `post_${Math.random().toString(36).substring(7)}`;
-    const post: ThreadsPost = {
-      id: postId,
-      media_product_type: "THREADS",
-      media_type: request.mediaType,
-      permalink,
-      owner: { id: request.userId },
-      username: "testuser",
-      text: request.text || "",
-      timestamp: new Date().toISOString(),
-      shortcode: postId,
-      is_quote_post: false,
-      hasReplies: false,
-      isReply: false,
-      isReplyOwnedByMe: false,
-    };
-    this.posts.set(postId, post);
-
-    // Always return an object with both id and permalink
-    return Promise.resolve({ id: containerId, permalink });
-  }
-
-  publishThreadsContainer(
-    _userId: string,
-    _accessToken: string,
-    containerId: string,
-    getPermalink: boolean = false
-  ): Promise<string | { id: string; permalink: string }> {
-    if (this.errorMode) {
-      return Promise.reject(new Error("Failed to publish Threads container"));
-    }
-    const container = this.containers.get(containerId);
-    if (!container) {
-      return Promise.reject(new Error("Container not found"));
-    }
-
-    // Find the post associated with this container
-    const existingPost = Array.from(this.posts.values()).find(
-      (post) => post.permalink === container.permalink
-    );
-
-    if (!existingPost) {
-      return Promise.reject(
-        new Error("Post not found for the given container")
-      );
-    }
-
-    return Promise.resolve(
-      getPermalink
-        ? { id: existingPost.id, permalink: existingPost.permalink || "" }
-        : existingPost.id
-    );
-  }
-
-  createCarouselItem(
-    request: Omit<ThreadsPostRequest, "mediaType"> & {
-      mediaType: "IMAGE" | "VIDEO";
-    }
-  ): Promise<string | { id: string }> {
-    const itemId = `item_${Math.random().toString(36).substring(7)}`;
-    const container: ThreadsContainer = {
-      id: itemId,
-      permalink: `https://www.threads.net/@${request.userId}/post/${itemId}`,
-      status: "FINISHED",
-    };
-    this.containers.set(itemId, container);
-    return Promise.resolve({ id: itemId });
-  }
-
-  getPublishingLimit(
-    userId: string,
-    _accessToken: string
-  ): Promise<PublishingLimit> {
-    if (this.errorMode) {
-      return Promise.reject(new Error("Failed to get publishing limit"));
-    }
-    const limit = this.publishingLimits.get(userId);
-    if (!limit) {
-      return Promise.reject(new Error("Publishing limit not found"));
-    }
-    return Promise.resolve(limit);
-  }
-
-  getThreadsList(
-    userId: string,
-    _accessToken: string,
-    options?: {
-      since?: string;
-      until?: string;
-      limit?: number;
-      after?: string;
-      before?: string;
-    }
-  ): Promise<ThreadsListResponse> {
-    const threads = Array.from(this.posts.values())
-      .filter((post) => post.owner.id === userId)
-      .slice(0, options?.limit || 25);
-
-    return Promise.resolve({
-      data: threads as ThreadsPost[],
-      paging: {
-        cursors: {
-          before: "BEFORE_CURSOR",
-          after: "AFTER_CURSOR",
-        },
-      },
-    });
-  }
-
-  getSingleThread(mediaId: string, _accessToken: string): Promise<ThreadsPost> {
-    const post = this.posts.get(mediaId);
-    if (!post) {
-      return Promise.reject(new Error("Thread not found"));
-    }
-    return Promise.resolve(post as ThreadsPost);
-  }
-}

package/types.ts

@@ -1,235 +0,0 @@
-// types.ts
-
-/**
- * Represents the types of media that can be posted on Threads.
- */
-export type MediaType = "TEXT" | "IMAGE" | "VIDEO" | "CAROUSEL";
-
-/**
- * Represents the options for controlling who can reply to a post.
- */
-export type ReplyControl =
-  | "everyone"
-  | "accounts_you_follow"
-  | "mentioned_only";
-
-/**
- * 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: MediaType;
-  /** The text content of the post (optional) */
-  text?: string;
-  /** The URL of the image to be posted (optional, for IMAGE type) */
-  imageUrl?: string;
-  /** The URL of the video to be posted (optional, for VIDEO type) */
-  videoUrl?: string;
-  /** The accessibility text for the image or video (optional) */
-  altText?: string;
-  /** The URL to be attached as a link to the post (optional, for text posts only) */
-  linkAttachment?: string;
-  /** List of country codes where the post should be visible (optional - requires special API access) */
-  allowlistedCountryCodes?: string[];
-  /** Controls who can reply to the post (optional) */
-  replyControl?: ReplyControl;
-  /** Array of carousel item IDs (required for CAROUSEL type, not applicable for other types) */
-  children?: string[];
-  /** Whether to return the permalink of the post (optional, default: false) */
-  getPermalink?: boolean;
-}
-
-/**
- * Represents a single Threads media object.
- */
-export interface ThreadsPost {
-  /** Unique identifier for the media object */
-  id: string;
-  /** Type of product where the media is published (e.g., "THREADS") */
-  media_product_type: string;
-  /** Type of media (e.g., "TEXT", "IMAGE", "VIDEO", "CAROUSEL") */
-  media_type: MediaType;
-  /** URL of the media content (if applicable) */
-  media_url?: string;
-  /** Permanent link to the post */
-  permalink?: string;
-  /** Information about the owner of the post */
-  owner: { id: string };
-  /** Username of the account that created the post */
-  username: string;
-  /** Text content of the post */
-  text?: string;
-  /** Timestamp of when the post was created (ISO 8601 format) */
-  timestamp: string;
-  /** Short code identifier for the media */
-  shortcode: string;
-  /** URL of the thumbnail image (for video posts) */
-  thumbnail_url?: string;
-  /** List of child posts (for carousel posts) */
-  children?: ThreadsPost[];
-  /** Indicates if the post is a quote of another post */
-  is_quote_post: boolean;
-  /** Accessibility text for the image or video */
-  altText?: string;
-  /** URL of the attached link */
-  linkAttachmentUrl?: string;
-  /** Indicates if the post has replies */
-  hasReplies: boolean;
-  /** Indicates if the post is a reply to another post */
-  isReply: boolean;
-  /** Indicates if the reply is owned by the current user */
-  isReplyOwnedByMe: boolean;
-  /** Information about the root post (for replies) */
-  rootPost?: { id: string };
-  /** Information about the post being replied to */
-  repliedTo?: { id: string };
-  /** Visibility status of the post */
-  hideStatus?: "VISIBLE" | "HIDDEN";
-  /** Controls who can reply to the post */
-  replyAudience?: ReplyControl;
-}
-
-/**
- * Represents the response structure when retrieving a list of Threads.
- */
-export interface ThreadsListResponse {
-  /** Array of ThreadsPost representing the retrieved posts */
-  data: ThreadsPost[];
-  /** Pagination information */
-  paging?: {
-    /** Cursors for navigating through pages of results */
-    cursors: {
-      /** Cursor for the previous page */
-      before: string;
-      /** Cursor for the next page */
-      after: string;
-    };
-  };
-}
-
-/**
- * Represents the publishing limit information for a user.
- */
-export interface PublishingLimit {
-  /** Current usage count towards the quota */
-  quota_usage: number;
-  /** Configuration for the publishing limit */
-  config: {
-    /** Total allowed quota */
-    quota_total: number;
-    /** Duration of the quota period in seconds */
-    quota_duration: number;
-  };
-}
-
-/**
- * Represents a Threads media container.
- */
-export interface ThreadsContainer {
-  /** Unique identifier for the container */
-  id: string;
-  /** Permanent link to the container */
-  permalink: string;
-  /** Status of the container */
-  status: "FINISHED" | "FAILED";
-  /** Error message if the container failed */
-  errorMessage?: string;
-}
-
-/**
- * Represents a Threads user profile.
- */
-export interface ThreadsProfile {
-  /** Unique identifier for the user */
-  id: string;
-  /** Username of the account */
-  username: string;
-  /** Display name of the user */
-  name: string;
-  /** URL of the user's profile picture */
-  threadsProfilePictureUrl: string;
-  /** Biography text of the user */
-  threadsBiography: string;
-}
-
-/**
- * Represents the mock API for Threads operations.
- */
-export interface MockThreadsAPI {
-  /**
-   * Creates a Threads media container.
-   * @param request The request object containing post details
-   * @returns A promise that resolves to either a string ID or an object with ID and permalink
-   */
-  createThreadsContainer(
-    request: ThreadsPostRequest
-  ): Promise<string | { id: string; permalink: string }>;
-
-  /**
-   * Publishes a Threads media container.
-   * @param userId The user ID
-   * @param accessToken The access token
-   * @param containerId The ID of the container to publish
-   * @param getPermalink Whether to return the permalink
-   * @returns A promise that resolves to either a string ID or an object with ID and permalink
-   */
-  publishThreadsContainer(
-    userId: string,
-    accessToken: string,
-    containerId: string,
-    getPermalink?: boolean
-  ): Promise<string | { id: string; permalink: string }>;
-
-  /**
-   * Creates a carousel item for a Threads post.
-   * @param request The request object containing carousel item details
-   * @returns A promise that resolves to either a string ID or an object with ID
-   */
-  createCarouselItem(
-    request: Omit<ThreadsPostRequest, "mediaType"> & {
-      mediaType: "IMAGE" | "VIDEO";
-    }
-  ): Promise<string | { id: string }>;
-
-  /**
-   * Retrieves the publishing limit for a user.
-   * @param userId The user ID
-   * @param accessToken The access token
-   * @returns A promise that resolves to the publishing limit information
-   */
-  getPublishingLimit(
-    userId: string,
-    accessToken: string
-  ): Promise<PublishingLimit>;
-
-  /**
-   * Retrieves a list of Threads posts for a user.
-   * @param userId The user ID
-   * @param accessToken The access token
-   * @param options Optional parameters for pagination and date range
-   * @returns A promise that resolves to the Threads list response
-   */
-  getThreadsList(
-    userId: string,
-    accessToken: string,
-    options?: {
-      since?: string;
-      until?: string;
-      limit?: number;
-      after?: string;
-      before?: string;
-    }
-  ): Promise<ThreadsListResponse>;
-
-  /**
-   * Retrieves a single Thread post.
-   * @param mediaId The ID of the media to retrieve
-   * @param accessToken The access token
-   * @returns A promise that resolves to the Thread post
-   */
-  getSingleThread(mediaId: string, accessToken: string): Promise<ThreadsPost>;
-}