project code

Author: wiseowldev

src/index.ts

@@ -0,0 +1,70 @@
+import { Attachment } from "./services/discord/types/attachment.types.js";
+import { Embed } from "./services/discord/types/embed.types.js";
+import WebhookService from "./services/discord/webhooks.js";
+import { PexelsPhotoService } from "./services/pexels/photos.js";
+import { Photo } from "./services/pexels/types.js";
+
+let pexelsService: PexelsPhotoService, webhookService: WebhookService;
+
+async function getRandomPexelsItem(): Promise<Photo> {
+    const res = await pexelsService.searchPhoto({
+        query: "frog",
+        per_page: 50,
+        page: 1,
+    });
+    if (res.photos.length == 0) throw new Error("No photos found");
+    return res.photos[(Math.random() * res.photos.length) | 0];
+}
+
+async function main() {
+    const apiToken = process.env.PEXELS_API_TOKEN;
+    if (!apiToken)
+        throw new Error("Missing environment variable 'PEXELS_API_TOKEN'");
+
+    const webhook = process.env.DISCORD_WEBHOOK;
+    if (!webhook)
+        throw new Error("Missing environment variable 'DISCORD_WEBHOOK'");
+
+    pexelsService = new PexelsPhotoService(apiToken);
+    webhookService = await new WebhookService().init(webhook);
+
+    const image = await getRandomPexelsItem();
+    const embed: Embed = {
+        title: image.id.toString(),
+        description: image.alt,
+        url: image.src.original,
+        thumbnail: {
+            url: image.src.tiny,
+        },
+        image: {
+            url: image.src.original,
+            height: 1000,
+            width: 1000,
+        },
+        color: Number(image.avg_color.replace("#", "0x")),
+        author: {
+            name: `${image.photographer} on Pexels`,
+            url: image.photographer_url,
+        },
+        footer: {
+            text: "images provided by pexels",
+            icon_url: "attachment://pexels.png",
+        },
+        fields: [
+            {
+                name: "width",
+                value: image.width.toString(),
+                inline: true,
+            },
+            {
+                name: "height",
+                value: image.height.toString(),
+                inline: true,
+            },
+        ],
+    };
+
+    await webhookService.send_embeds([embed]);
+}
+
+main().catch(console.error);

src/services/discord/constants.ts

@@ -0,0 +1 @@
+export const API_BASE_URL = "https://discord.com/api";

src/services/discord/types/attachment.types.ts

@@ -0,0 +1,19 @@
+/**
+ * For more information, see [documentation](https://discord.com/developers/docs/resources/message#attachment-object)
+ */
+export type Attachment = {
+    id: string;
+    filename: string;
+    title?: string;
+    description?: string;
+    content_type?: string;
+    size?: number;
+    url?: string;
+    proxy_url?: string;
+    height?: number;
+    width?: number;
+    ephermal?: boolean;
+    duration_secs?: number;
+    waveform?: string;
+    flags?: number;
+};

src/services/discord/types/embed.types.ts

@@ -0,0 +1,65 @@
+/**
+ * For more information, see the [documentation](https://discord.com/developers/docs/resources/message#embed-object)
+ */
+export type Embed = {
+    title?: string;
+    type?: EmbedType;
+    description?: string;
+    url?: string;
+    timestamp?: Date;
+    color?: number;
+    footer?: EmbedFooter;
+    image?: EmbedImage;
+    thumbnail?: EmbedThumbnail;
+    video?: EmbedVideo;
+    provider?: EmbedProvider;
+    author?: EmbedAuthor;
+    fields?: EmbedField[];
+};
+
+type EmbedType = "rich" | "image" | "video" | "gifv" | "article" | "link";
+
+type EmbedFooter = {
+    text: string;
+    icon_url?: string;
+    proxy_icon_url?: string;
+};
+
+type EmbedImage = {
+    url: string;
+    proxy_url?: string;
+    height?: number;
+    width?: number;
+};
+
+type EmbedThumbnail = {
+    url: string;
+    proxy_url?: string;
+    height?: number;
+    width?: number;
+};
+
+type EmbedVideo = {
+    url?: string;
+    proxy_url?: string;
+    height?: number;
+    width?: number;
+};
+
+type EmbedProvider = {
+    name?: string;
+    url?: string;
+};
+
+type EmbedAuthor = {
+    name: string;
+    url?: string;
+    icon_url?: string;
+    proxy_icon_url?: string;
+};
+
+type EmbedField = {
+    name: string;
+    value: string;
+    inline?: boolean;
+};

src/services/discord/types/webhook.types.ts

@@ -0,0 +1,20 @@
+import { Attachment } from "./attachment.types.js";
+import { Embed } from "./embed.types.js";
+
+type BaseExecuteParams = {
+    username?: string;
+    avatar_url?: string;
+    tts?: boolean;
+    allowed_mentions?: "roles" | "users" | "everyone";
+    attachments?: Attachment[];
+    thread_name?: string;
+    applied_tags?: string[];
+};
+
+export type EmbedExecuteParams = BaseExecuteParams & {
+    embeds?: Embed[];
+};
+
+export type ContentExecuteParams = BaseExecuteParams & {
+    content: string;
+};

src/services/discord/webhooks.ts

@@ -0,0 +1,57 @@
+import { API_BASE_URL } from "./constants.js";
+import { Attachment } from "./types/attachment.types.js";
+import { Embed } from "./types/embed.types.js";
+import { EmbedExecuteParams } from "./types/webhook.types.js";
+
+export default class WebhookService {
+    private __token: string;
+    private __webhookId: string;
+
+    public async init(webhook: string) {
+        const response = await fetch(webhook);
+        if (!response.ok) {
+            const message = await response.text();
+            throw new Error(
+                `Unable to retrieve webhook details [${response.status} - ${response.statusText}]`,
+            );
+        }
+
+        const data = await response.json();
+        this.__token = data["token"];
+        this.__webhookId = data["id"];
+        return this;
+    }
+
+    private getWebhookUrl() {
+        return `${API_BASE_URL}/webhooks/${this.__webhookId}/${this.__token}`;
+    }
+
+    public async send_embeds(embeds: Embed[], attachments?: Attachment[]) {
+        if (embeds.length == 0)
+            throw new Error("Expected at least 1, and at max 10 embeds.");
+        if (embeds.length > 10)
+            throw new Error(
+                "Can only send a maximum of 10 embeds via discord webhooks.",
+            );
+        for (let i = 0; i < embeds.length; ++i) embeds[i].type = "rich";
+
+        const headers = { "Content-Type": "application/json" };
+        const data: EmbedExecuteParams = {
+            embeds,
+            ...(((attachments?.length ?? 0) > 0 && { attachments }) || {}),
+        };
+
+        const res = await fetch(this.getWebhookUrl(), {
+            method: "POST",
+            headers: headers,
+            body: JSON.stringify(data),
+        });
+
+        if (!res.ok) {
+            const message = await res.text();
+            throw new Error(
+                `Failed to send the embeds [${res.status} - ${res.statusText}]\n${message}`,
+            );
+        }
+    }
+}

src/services/pexels/constants.ts

@@ -0,0 +1 @@
+export const API_BASE_URL = "https://api.pexels.com";

src/services/pexels/photos.interfaces.ts

@@ -0,0 +1,20 @@
+import { Color, Locale, Orientation, Size, Photo } from "./types.ts";
+
+export interface ISearchPhotoParams {
+    query?: string;
+    orientation?: Orientation;
+    size?: Size;
+    color?: Color;
+    locale?: Locale;
+    page?: number;
+    per_page?: number;
+}
+
+export interface ISearchPhotoResponse {
+    photos: Photo[];
+    page: number;
+    per_page: number;
+    total_results: number;
+    prev_page: number;
+    next_page: number;
+}

src/services/pexels/photos.ts

@@ -0,0 +1,39 @@
+import { API_BASE_URL } from "./constants.js";
+import {
+    ISearchPhotoParams,
+    ISearchPhotoResponse,
+} from "./photos.interfaces.js";
+
+export class PexelsPhotoService {
+    private __token: string;
+
+    constructor(apiToken: string) {
+        this.__token = apiToken;
+    }
+
+    public async searchPhoto(
+        params: ISearchPhotoParams,
+    ): Promise<ISearchPhotoResponse> {
+        const sParams = new URLSearchParams();
+        const entries = Object.entries(params);
+        for (let i = 0; i < entries.length; i++) {
+            const [k, v] = entries[i];
+            if (v !== undefined) sParams.set(k, v.toString());
+        }
+
+        const response = await fetch(
+            `${API_BASE_URL}/v1/search?${sParams.toString()}`,
+            {
+                headers: {
+                    Authorization: this.__token,
+                },
+            },
+        );
+
+        if (!response.ok)
+            throw new Error(
+                `Error searching for images [code: ${response.status}]`,
+            );
+        return await response.json();
+    }
+}

src/services/pexels/types.ts

@@ -0,0 +1,48 @@
+type HexColor = string;
+function assertHexColor(value: string): asserts value is HexColor {
+    const hexRegex = /^#([0-9a-fA-F]{2}){3}$/;
+    if (!hexRegex.test(value)) {
+        throw new Error(`${value} is not a valid hexadecimal color code.`);
+    }
+}
+
+export type Orientation = "portrait" | "landscape" | "square";
+export type Size = "small" | "medium" | "large";
+export type Color =
+    | "red"
+    | "orange"
+    | "yellow"
+    | "green"
+    | "turquoise"
+    | "blue"
+    | "violet"
+    | "pink"
+    | "brown"
+    | "black"
+    | "grey"
+    | "white"
+    | HexColor;
+export type Locale = string;
+
+export type Photo = {
+    id: number;
+    width: number;
+    height: number;
+    url: string;
+    photographer: string;
+    photographer_url: string;
+    photographer_id: number;
+    avg_color: HexColor;
+    src: {
+        original: string;
+        large2x: string;
+        large: string;
+        medium: string;
+        small: string;
+        portrait: string;
+        landscape: string;
+        tiny: string;
+    };
+    liked: boolean;
+    alt: string;
+};