cdransf/coryd.dev-astro
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: cloudflare -> netlify

Browse source
This commit is contained in:
Cory Dransfeldt 2024-11-29 15:12:47 -08:00
parent a7e0b36d82
commit a74ea3644d
No known key found for this signature in database
41 changed files with 2021 additions and 2395 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
.env
View file

@ -2,6 +2,11 @@ ACCOUNT_ID_PLEX=
API_KEY_PLAUSIBLE=
SUPABASE_URL=
SUPABASE_KEY=
CF_ACCOUNT_ID=
CF_ZONE_ID=
RSS_TO_MASTODON_KV_NAMESPACE_ID=
DIRECTUS_URL=
DIRECTUS_TOKEN=
ARTIST_IMPORT_TOKEN=
ARTIST_FLOW_ID=
ALBUM_FLOW_ID=
MASTODON_ACCESS_TOKEN=
FORWARDEMAIL_API_KEY=
CDN=

17
.github/workflows/scheduled-deploy.yaml vendored Normal file
View file

@ -0,0 +1,17 @@
name: Scheduled deploy
on:
schedule:
- cron: "0 * * * *"
workflow_dispatch:
jobs:
trigger-netlify-build:
runs-on: ubuntu-latest
steps:
- name: Trigger Netlify Build Hook
run: |
curl -X POST -d '{}' \
-H "Content-Type: application/json" \
"${{secrets.DEPLOY_HOOK}}"

8
.gitignore vendored
View file

@ -1,10 +1,6 @@
# build output
dist/
# workers
wrangler.toml
.wrangler
# generated types
.astro/
@ -23,5 +19,5 @@ pnpm-debug.log*
# macOS-specific files
.DS_Store
# VS Code files
.vscode/
# netlify
.netlify

2
.npmrc
View file

@ -1,2 +0,0 @@
save-exact=true
cache=~/.npm

2
.nvmrc
View file

@ -1 +1 @@
22
20

23
README.md
View file

@ -1,5 +1,7 @@
# coryd.dev
[![Netlify Status](https://api.netlify.com/api/v1/badges/21438096-e0d0-4f14-846d-addd9d8292db/deploy-status)](https://app.netlify.com/sites/coryd/deploys)
Hi! I'm Cory. 👋🏻
This is the code for my personal website and portfolio. Built using [Astro](https://astro.build) and [other tools](https://coryd.dev/colophon).
@ -24,11 +26,11 @@ This is the code for my personal website and portfolio. Built using [Astro](http
### Other commands
`npm run build`: builds Astro output.
`npm run prevew`: previews built Astro output (uses wrangler command compatible with Cloudflare adapter under the hood).
`npm run update:deps`: checks for dependency updates and updates Astro.
`npm run build:worker -- WORKER_NAME`: builds the `wrangler.toml` file for the named worker.
`npm run deploy:worker --worker=WORKER_NAME`: deploys the named worker.
`npm run build`: builds Astro output.
`npm run prevew`: previews built Astro output (uses wrangler command compatible with Cloudflare adapter under the hood).
`npm run update:deps`: checks for dependency updates and updates Astro.
`netlify dev`: local development with Netlify functions.
## Required environment variables
@ -37,7 +39,12 @@ ACCOUNT_ID_PLEX
API_KEY_PLAUSIBLE
SUPABASE_URL
SUPABASE_KEY
CF_ACCOUNT_ID
CF_ZONE_ID
RSS_TO_MASTODON_KV_NAMESPACE_ID
DIRECTUS_URL
DIRECTUS_TOKEN
ARTIST_IMPORT_TOKEN
ARTIST_FLOW_ID
ALBUM_FLOW_ID
MASTODON_ACCESS_TOKEN
FORWARDEMAIL_API_KEY
CDN
```

9
astro.config.mjs
View file

@ -1,12 +1,15 @@
import { defineConfig } from "astro/config";
import cloudflare from "@astrojs/cloudflare";
import netlify from "@astrojs/netlify";
import sitemap from "@astrojs/sitemap";
import sitemapData from "./src/utils/data/static/sitemapData.json";
import sitemapData from "./src/utils/data/static/sitemapData.json" assert { type: "json" };
export default defineConfig({
site: "https://coryd.dev",
output: "server",
adapter: cloudflare(),
adapter: netlify({
cacheOnDemandPages: true,
imageCDN: false,
}),
integrations: [
sitemap({
customPages: sitemapData.map((entry) => entry.loc),

204
functions/artist-import.js Normal file
View file

@ -0,0 +1,204 @@
import slugify from "slugify";
import countries from "i18n-iso-countries";
import enLocale from "i18n-iso-countries/langs/en.json" assert { type: "json" };
countries.registerLocale(enLocale);
function sanitizeMediaString(str) {
return slugify(
str
.normalize("NFD")
.replace(/[\u0300-\u036f\u2010\-\.\?\(\)\[\]\{\}]/g, "")
.replace(/\.{3}/g, ""),
{
replacement: "-",
remove: /[#,&,+()$~%.'":*?<>{}]/g,
lower: true,
},
);
}
export async function handler(event, context) {
const {
DIRECTUS_URL,
DIRECTUS_API_TOKEN,
ARTIST_IMPORT_TOKEN,
ARTIST_FLOW_ID,
ALBUM_FLOW_ID,
} = process.env;
const placeholderImageId = "4cef75db-831f-4f5d-9333-79eaa5bb55ee";
const requestUrl = new URL(event.rawUrl);
const providedToken = requestUrl.searchParams.get("token");
if (!providedToken || providedToken !== ARTIST_IMPORT_TOKEN) {
return {
statusCode: 401,
body: "Unauthorized",
};
}
async function saveToDirectus(endpoint, payload) {
try {
const response = await fetch(`${DIRECTUS_URL}/items/${endpoint}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${DIRECTUS_API_TOKEN}`,
},
body: JSON.stringify(payload),
});
const data = await response.json();
if (!response.ok) {
throw new Error(
data.errors?.[0]?.message || "Failed to save to Directus",
);
}
return data.data;
} catch (error) {
console.error(`Error saving to ${endpoint}:`, error.message);
throw error;
}
}
async function findGenreIdByName(genreName) {
try {
const response = await fetch(
`${DIRECTUS_URL}/items/genres?filter[name][_eq]=${encodeURIComponent(
genreName.toLowerCase(),
)}`,
{ headers: { Authorization: `Bearer ${DIRECTUS_API_TOKEN}` } },
);
const data = await response.json();
return data.data?.[0]?.id || null;
} catch (error) {
console.error("Error fetching genre ID:", error.message);
return null;
}
}
const artistId = requestUrl.searchParams.get("artist_id");
if (!artistId) {
return {
statusCode: 400,
body: "artist_id parameter is required",
};
}
let artistData;
try {
const artistResponse = await fetch(
`${DIRECTUS_URL}/flows/trigger/${ARTIST_FLOW_ID}?artist_id=${artistId}&import_token=${ARTIST_IMPORT_TOKEN}`,
{ headers: { Authorization: `Bearer ${DIRECTUS_API_TOKEN}` } },
);
const artistResult = await artistResponse.json();
artistData =
artistResult.get_artist_data?.data?.MediaContainer?.Metadata?.[0];
if (!artistData) throw new Error("Artist data not found");
} catch (error) {
console.error("Error fetching artist data:", error.message);
return {
statusCode: 500,
body: "Error fetching artist data",
};
}
const artistName = artistData.title || "";
const artistKey = sanitizeMediaString(artistName);
const countryName = artistData.Country?.[0]?.tag || "";
const countryIsoCode = countries.getAlpha2Code(countryName, "en") || "";
const slug = `/music/artists/${artistKey}-${countryName.toLowerCase()}`;
const description = artistData.summary || "";
const mbid = artistData.Guid?.[0]?.id?.replace("mbid://", "") || "";
const genreNames = artistData.Genre?.map((g) => g.tag.toLowerCase()) || [];
let genreId = null;
for (const genreName of genreNames) {
genreId = await findGenreIdByName(genreName);
if (genreId) break;
}
const artistPayload = {
name: artistName,
name_string: artistName,
slug,
description,
mbid,
tentative: true,
genres: genreId,
country: countryIsoCode,
art: placeholderImageId,
};
let insertedArtist;
try {
insertedArtist = await saveToDirectus("artists", artistPayload);
} catch (error) {
console.error("Error saving artist:", error.message);
return {
statusCode: 500,
body: "Error saving artist",
};
}
let albumData;
try {
const albumResponse = await fetch(
`${DIRECTUS_URL}/flows/trigger/${ALBUM_FLOW_ID}?artist_id=${artistId}&import_token=${ARTIST_IMPORT_TOKEN}`,
{ headers: { Authorization: `Bearer ${DIRECTUS_API_TOKEN}` } },
);
const albumResult = await albumResponse.json();
albumData =
albumResult.get_album_data?.data?.MediaContainer?.Metadata || [];
} catch (error) {
console.error("Error fetching album data:", error.message);
return {
statusCode: 500,
body: "Error fetching album data",
};
}
for (const album of albumData) {
const albumName = album.title || "";
const albumKey = `${artistKey}-${sanitizeMediaString(albumName)}`;
const albumSlug = `/music/albums/${albumKey}`;
const albumDescription = album.summary || "";
const albumReleaseDate = album.originallyAvailableAt || "";
const albumReleaseYear = albumReleaseDate
? new Date(albumReleaseDate).getFullYear()
: null;
const albumGenres = album.Genre?.map((g) => g.tag) || [];
const albumMbid = album.Guid?.[0]?.id?.replace("mbid://", "") || null;
const albumPayload = {
name: albumName,
key: albumKey,
slug: albumSlug,
mbid: albumMbid,
description: albumDescription,
release_year: albumReleaseYear,
artist: insertedArtist.id,
artist_name: artistName,
genres: albumGenres,
art: placeholderImageId,
tentative: true,
};
try {
await saveToDirectus("albums", albumPayload);
} catch (error) {
console.error("Error saving album:", error.message);
}
}
return {
statusCode: 200,
body: "Artist and albums synced successfully",
};
}

191
workers/mastodon/index.js → functions/mastodon.js
View file

@ -1,87 +1,16 @@
import { XMLParser } from "fast-xml-parser";
import { convert } from "html-to-text";
import { createClient } from "@supabase/supabase-js";
const BASE_URL = "https://coryd.dev";
export default {
async scheduled(event, env) {
await handleMastodonPost(env);
},
};
async function handleMastodonPost(env) {
const mastodonApiUrl = "https://follow.coryd.dev/api/v1/statuses";
const accessToken = env.MASTODON_ACCESS_TOKEN;
const rssFeedUrl = "https://coryd.dev/feeds/syndication.xml";
const supabaseUrl = env.SUPABASE_URL;
const supabaseKey = env.SUPABASE_KEY;
const supabase = createClient(supabaseUrl, supabaseKey);
try {
const latestItems = await fetchRSSFeed(rssFeedUrl);
for (let i = latestItems.length - 1; i >= 0; i--) {
const item = latestItems[i];
const existingPost = await env.RSS_TO_MASTODON_NAMESPACE.get(item.link);
if (existingPost) continue;
const title = item.title;
const link = item.link;
const maxLength = 500;
const plainTextDescription = convert(item.description, {
wordwrap: false,
selectors: [
{ selector: "a", options: { ignoreHref: true } },
{ selector: "h1", options: { uppercase: false } },
{ selector: "h2", options: { uppercase: false } },
{ selector: "h3", options: { uppercase: false } },
{ selector: "*", format: "block" },
],
});
const cleanedDescription = plainTextDescription
.replace(/\s+/g, " ")
.trim();
const content = truncateContent(
title,
cleanedDescription,
link,
maxLength
);
const mastodonPostUrl = await postToMastodon(
mastodonApiUrl,
accessToken,
content
);
const timestamp = new Date().toISOString();
await env.RSS_TO_MASTODON_NAMESPACE.put(link, timestamp);
if (link.includes("coryd.dev/posts")) {
const slug = link.replace(BASE_URL, "");
await addMastodonUrlToPost(supabase, slug, mastodonPostUrl);
}
console.log(`Posted stored URL: ${link}`);
}
console.log("RSS processed successfully");
} catch (error) {
console.error("Error in scheduled event:", error);
}
}
async function addMastodonUrlToPost(supabase, slug, mastodonPostUrl) {
const { data, error } = await supabase
const { error } = await supabase
.from("posts")
.update({ mastodon_url: mastodonPostUrl })
.eq("slug", slug);
if (error) {
console.error("Error updating post:", error);
console.error("Error updating post in 'posts' table:", error.message);
} else {
console.log(`Updated post with Mastodon URL: ${mastodonPostUrl}`);
}
@ -112,16 +41,11 @@ async function fetchRSSFeed(rssFeedUrl) {
const rssData = parser.parse(rssText);
const items = rssData.rss.channel.item;
let latestItems = [];
items.forEach((item) => {
const title = item.title;
const link = item.link;
const description = item.description;
latestItems.push({ title, link, description });
});
return latestItems;
return items.map((item) => ({
title: item.title,
link: item.link,
description: item.description,
}));
}
async function postToMastodon(apiUrl, accessToken, content) {
@ -137,13 +61,106 @@ async function postToMastodon(apiUrl, accessToken, content) {
if (!response.ok) {
const errorText = await response.text();
throw new Error(
`Error posting to Mastodon: ${response.statusText} - ${errorText}`
`Error posting to Mastodon: ${response.statusText} - ${errorText}`,
);
}
const responseData = await response.json();
console.log("Posted to Mastodon successfully.");
return responseData.url;
}
async function fetchFromSupabase(supabase, link) {
const { data, error } = await supabase
.from("mastodon_posts")
.select("link")
.eq("link", link)
.single();
if (error && error.code !== "PGRST116") {
console.error("Error fetching from Supabase:", error.message);
return null;
}
return data;
}
async function storeInSupabase(supabase, link, timestamp) {
const { error } = await supabase.from("mastodon_posts").insert([
{
link,
created_at: timestamp,
},
]);
if (error) {
console.error("Error storing in Supabase:", error.message);
} else {
console.log("Successfully stored processed link in 'mastodon_posts'");
}
}
async function handleMastodonPost(env, supabase) {
const mastodonApiUrl = "https://follow.coryd.dev/api/v1/statuses";
const accessToken = env.MASTODON_ACCESS_TOKEN;
const rssFeedUrl = "https://coryd.dev/feeds/syndication.xml";
try {
const latestItems = await fetchRSSFeed(rssFeedUrl);
for (let i = latestItems.length - 1; i >= 0; i--) {
const item = latestItems[i];
const existingPost = await fetchFromSupabase(supabase, item.link);
if (existingPost) continue;
const title = item.title;
const link = item.link;
const maxLength = 500;
const cleanedDescription = item.description.replace(/\s+/g, " ").trim();
const content = truncateContent(
title,
cleanedDescription,
link,
maxLength,
);
const mastodonPostUrl = await postToMastodon(
mastodonApiUrl,
accessToken,
content,
);
const timestamp = new Date().toISOString();
await storeInSupabase(supabase, item.link, timestamp);
if (link.includes("coryd.dev/posts")) {
const slug = link.replace(BASE_URL, "");
await addMastodonUrlToPost(supabase, slug, mastodonPostUrl);
}
console.log(`Posted and stored URL: ${link}`);
}
console.log("RSS processed successfully");
} catch (error) {
console.error("Error in Mastodon posting process:", error);
}
}
export async function handler(event, context) {
const env = process.env;
try {
const supabase = createClient(env.SUPABASE_URL, env.SUPABASE_KEY);
await handleMastodonPost(env, supabase);
return {
statusCode: 200,
body: "RSS processed successfully",
};
} catch (error) {
console.error("Error in Netlify function:", error);
return {
statusCode: 500,
body: "Internal Server Error",
};
}
}

288
functions/scrobble.js Normal file
View file

@ -0,0 +1,288 @@
import { createClient } from "@supabase/supabase-js";
import slugify from "slugify";
const sanitizeMediaString = (str) => {
const sanitizedString = str
.normalize("NFD")
.replace(/[\u0300-\u036f\u2010\-\.\?\(\)\[\]\{\}]/g, "")
.replace(/\.{3}/g, "");
return slugify(sanitizedString, {
replacement: "-",
remove: /[#,&,+()$~%.'":*?<>{}]/g,
lower: true,
});
};
const sendEmail = async (subject, text, authHeader, maxRetries = 3) => {
const emailData = new URLSearchParams({
from: "coryd.dev <hi@admin.coryd.dev>",
to: "hi@coryd.dev",
subject: subject,
text: text,
}).toString();
let attempt = 0;
let success = false;
while (attempt < maxRetries && !success) {
attempt++;
try {
const response = await fetch("https://api.forwardemail.net/v1/emails", {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
Authorization: authHeader,
},
body: emailData,
});
if (!response.ok) {
const responseText = await response.text();
console.error(
`Attempt ${attempt}: Email API response error:`,
response.status,
responseText,
);
throw new Error(`Failed to send email: ${responseText}`);
}
console.log("Email sent successfully on attempt", attempt);
success = true;
} catch (error) {
console.error(`Attempt ${attempt}: Error sending email.`);
if (attempt < maxRetries) {
console.log(
`Retrying email send (attempt ${attempt + 1}/${maxRetries})...`,
);
} else {
console.error("All attempts to send email failed.");
}
}
}
return success;
};
const parseMultipartFormData = (body, boundary) => {
const parts = body.split(`--${boundary}`).filter((part) => part.trim());
const formData = {};
parts.forEach((part) => {
const [headers, value] = part.split("\r\n\r\n");
const nameMatch = headers.match(/name="(.+?)"/);
if (nameMatch) {
const name = nameMatch[1];
formData[name] = value.trim().replace(/\r\n$/, "");
}
});
return formData;
};
export async function handler(event, context) {
const supabaseUrl = process.env.SUPABASE_URL;
const supabaseKey = process.env.SUPABASE_KEY;
const FORWARDEMAIL_API_KEY = process.env.FORWARDEMAIL_API_KEY;
const ACCOUNT_ID_PLEX = process.env.ACCOUNT_ID_PLEX;
const authHeader = "Basic " + btoa(`${FORWARDEMAIL_API_KEY}:`);
const supabase = createClient(supabaseUrl, supabaseKey);
let id;
try {
const queryParams = new URLSearchParams(event.queryStringParameters || {});
id = queryParams.get("id");
if (!id || id !== ACCOUNT_ID_PLEX)
return {
statusCode: 403,
body: JSON.stringify({
status: "Forbidden",
message: "Invalid or missing ID",
}),
};
} catch (error) {
console.error("Error parsing query parameters.");
return {
statusCode: 400,
body: JSON.stringify({
status: "Bad request",
message: "Oops! Bad request.",
}),
};
}
const contentType = event.headers["content-type"] || "";
if (!contentType.includes("multipart/form-data"))
return {
statusCode: 400,
body: JSON.stringify({
status: "Bad request",
message: "Invalid Content-Type. Expected multipart/form-data.",
}),
};
try {
const boundary = contentType.split("boundary=")[1];
if (!boundary) throw new Error("Missing boundary in Content-Type");
const rawBody = Buffer.from(event.body, "base64").toString("utf-8");
const formData = parseMultipartFormData(rawBody, boundary);
const payload = JSON.parse(formData.payload);
console.log("Parsed payload:", payload);
if (payload?.event === "media.scrobble") {
const artistName = payload["Metadata"]["grandparentTitle"];
const albumName = payload["Metadata"]["parentTitle"];
const trackName = payload["Metadata"]["title"];
const listenedAt = Math.floor(Date.now() / 1000);
const artistKey = sanitizeMediaString(artistName);
const albumKey = `${artistKey}-${sanitizeMediaString(albumName)}`;
let { data: artistData, error: artistError } = await supabase
.from("artists")
.select("*")
.ilike("name_string", artistName)
.single();
if (artistError && artistError.code === "PGRST116") {
const { error: insertArtistError } = await supabase
.from("artists")
.insert([
{
mbid: null,
art: "4cef75db-831f-4f5d-9333-79eaa5bb55ee",
name: artistName,
slug: "/music",
tentative: true,
total_plays: 0,
},
]);
if (insertArtistError) {
console.error("Error inserting artist.");
return {
statusCode: 500,
body: JSON.stringify({
status: "error",
message: "Error inserting artist.",
}),
};
}
await sendEmail(
"New tentative artist record",
`A new tentative artist record was inserted:\n\nArtist: ${artistName}\nKey: ${artistKey}`,
authHeader,
);
({ data: artistData, error: artistError } = await supabase
.from("artists")
.select("*")
.ilike("name_string", artistName)
.single());
}
if (artistError) {
console.error("Artist not found or created.");
return {
statusCode: 500,
body: JSON.stringify({
status: "error",
message: "Artist not found",
}),
};
}
let { data: albumData, error: albumError } = await supabase
.from("albums")
.select("*")
.ilike("key", albumKey)
.single();
if (albumError && albumError.code === "PGRST116") {
console.log("Inserting new album:", albumName);
const { error: insertAlbumError } = await supabase
.from("albums")
.insert([
{
mbid: null,
art: "4cef75db-831f-4f5d-9333-79eaa5bb55ee",
key: albumKey,
name: albumName,
tentative: true,
total_plays: 0,
artist: artistData.id,
},
]);
if (insertAlbumError) {
console.error("Error inserting album.");
return {
statusCode: 500,
body: JSON.stringify({
status: "error",
message: "Error inserting album.",
}),
};
}
await sendEmail(
"New tentative album record",
`A new tentative album record was inserted:\n\nAlbum: ${albumName}\nKey: ${albumKey}\nArtist: ${artistName}`,
authHeader,
);
({ data: albumData, error: albumError } = await supabase
.from("albums")
.select("*")
.ilike("key", albumKey)
.single());
}
if (albumError) {
console.error("Album not found or created.");
return {
statusCode: 500,
body: JSON.stringify({ status: "error", message: "Album not found" }),
};
}
const { error: listenError } = await supabase.from("listens").insert([
{
artist_name: artistData.name_string || artistName,
album_name: albumData.name || albumName,
track_name: trackName,
listened_at: listenedAt,
album_key: albumKey,
},
]);
if (listenError) {
console.error("Error inserting listen.");
return {
statusCode: 500,
body: JSON.stringify({
status: "error",
message: "Error inserting listen.",
}),
};
}
console.log("Listen record inserted successfully");
}
return {
statusCode: 200,
body: JSON.stringify({ status: "success" }),
};
} catch (e) {
console.error("Error occurred during request processing:", e.message, e.stack);
return {
statusCode: 500,
body: JSON.stringify({ status: "error", message: "Oops! Error." }),
};
}
}

53
functions/search.js Normal file
View file

@ -0,0 +1,53 @@
import { createClient } from "@supabase/supabase-js";
export async function handler(event, context) {
const supabaseUrl = process.env.SUPABASE_URL;
const supabaseKey = process.env.SUPABASE_KEY;
const supabase = createClient(supabaseUrl, supabaseKey);
try {
const searchParams = event.queryStringParameters || {};
const query = searchParams.q?.trim() || "";
const rawTypes = searchParams.type || "";
const types = rawTypes ? rawTypes.split(",") : null;
const page = parseInt(searchParams.page || "1", 10);
const pageSize = parseInt(searchParams.pageSize || "10", 10);
const offset = (page - 1) * pageSize;
if (!query) throw new Error("Missing or invalid 'q' parameter");
const { data, error } = await supabase.rpc("search_optimized_index", {
search_query: query,
page_size: pageSize,
page_offset: offset,
types: types && types.length ? types : null,
});
if (error) {
console.error("Error fetching search data:", error.message);
return {
statusCode: 500,
body: JSON.stringify({
results: [],
total: 0,
error: error.message,
}),
};
}
const total = data.length > 0 ? data[0].total_count : 0;
const results = data.map(({ total_count, ...item }) => item);
return {
statusCode: 200,
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ results, total, page, pageSize }),
};
} catch (error) {
console.error("Unexpected error:", error.message);
return {
statusCode: error.message.includes("Missing or invalid") ? 400 : 500,
body: JSON.stringify({ error: error.message }),
};
}
}

38
netlify.toml Normal file
View file

@ -0,0 +1,38 @@
[build]
command = "npm run build"
publish = "dist"
[functions]
directory = "functions"
[functions.mastodon]
schedule = "*/15 * * * *"
[[redirects]]
from = "/api/artist-import"
to = "/.netlify/functions/artist-import"
status = 200
[[redirects]]
from = "/api/scrobble"
to = "/.netlify/functions/scrobble"
status = 200
query = "*"
[[redirects]]
from = "/api/search"
to = "/.netlify/functions/search"
status = 200
query = "*"
[[redirects]]
from = "/scripts/util.js"
to = "https://plausible.io/js/plausible.outbound-links.tagged-events.js"
status = 200
force = true
[[redirects]]
from = "/api/event"
to = "https://plausible.io/api/event"
status = 200
force = true

2424
package-lock.json generated
View file

File diff suppressed because it is too large Load diff

39
package.json
View file

@ -3,47 +3,44 @@
"type": "module",
"version": "1.5.1",
"scripts": {
"dev": "astro dev",
"start": "astro dev",
"build": "astro build",
"preview": "wrangler pages dev ./dist",
"astro": "astro",
"clean": "rimraf dist",
"sitemap:generate": "node scripts/sitemap-generate.mjs",
"update": "npm upgrade && ncu && npx @astrojs/upgrade && npm i && node scripts/sitemap-generate.mjs",
"update:deps": "npm upgrade && ncu && npx @astrojs/upgrade && npm i",
"build:worker": "node scripts/worker-build.mjs $WORKER_NAME",
"deploy:worker": "wrangler deploy --env production --config workers/$npm_config_worker/wrangler.toml"
"update:deps": "npm upgrade && ncu && npx @astrojs/upgrade && npm i"
},
"dependencies": {
"@astrojs/check": "0.9.4",
"@astrojs/cloudflare": "^11.2.0",
"@astrojs/rss": "4.0.9",
"@astrojs/sitemap": "3.2.1",
"@cdransf/astro-tabler-icons": "1.2.0",
"@astrojs/netlify": "^5.5.4",
"@supabase/supabase-js": "^2.46.2",
"astro": "4.16.16",
"astro-embed": "0.9.0",
"date-fns": "4.1.0",
"date-fns-tz": "3.2.0",
"cdn-cache-control": "^1.2.0",
"highlight.js": "11.10.0",
"markdown-it": "14.1.0",
"markdown-it-anchor": "9.2.0",
"markdown-it-footnote": "4.0.0",
"minisearch": "7.1.1",
"sanitize-html": "2.13.1",
"truncate-html": "1.1.2",
"youtube-video-element": "^1.1.6"
},
"devDependencies": {
"dotenv": "16.4.5",
"dotenv-flow": "4.1.0",
"@astrojs/check": "0.9.4",
"@astrojs/rss": "4.0.9",
"@astrojs/sitemap": "3.2.1",
"@cdransf/astro-tabler-icons": "1.2.0",
"astro-embed": "0.9.0",
"date-fns": "4.1.0",
"date-fns-tz": "3.2.0",
"dotenv": "^16.4.5",
"dotenv-flow": "^4.1.0",
"fast-xml-parser": "4.5.0",
"html-to-text": "9.0.5",
"i18n-iso-countries": "7.13.0",
"ics": "^3.8.1",
"markdown-it": "14.1.0",
"markdown-it-anchor": "9.2.0",
"markdown-it-footnote": "4.0.0",
"minisearch": "7.1.1",
"rimraf": "6.0.1",
"slugify": "1.6.6",
"terser": "5.36.0"
"terser": "5.36.0",
"truncate-html": "1.1.2"
}
}

3
public/_redirects
View file

@ -1,3 +1,6 @@
# apex
https://coryd.netlify.app/* https://coryd.dev/:splat 301!
# 404s
/now.html /now 301
/contact.html /contact 301

33
scripts/worker-build.mjs
View file

@ -1,33 +0,0 @@
import fs from 'fs/promises'
import dotenv from 'dotenv-flow'
dotenv.config()
const workerName = process.argv[2]
if (!workerName) {
console.error('Please specify a worker name.')
process.exit(1)
}
const templatePath = `workers/${workerName}/wrangler.template.toml`
const outputPath = `workers/${workerName}/wrangler.toml`
async function generateToml() {
try {
const template = await fs.readFile(templatePath, 'utf8')
const output = template
.replace(/\${CF_ACCOUNT_ID}/g, process.env.CF_ACCOUNT_ID)
.replace(/\${CF_ZONE_ID}/g, process.env.CF_ZONE_ID)
.replace(/\${RSS_TO_MASTODON_KV_NAMESPACE_ID}/g, process.env.RSS_TO_MASTODON_KV_NAMESPACE_ID)
await fs.writeFile(outputPath, output)
console.log(`Generated wrangler.toml for ${workerName}`)
} catch (error) {
console.error('Error generating wrangler.toml:', error)
process.exit(1)
}
}
generateToml()

2
src/components/IconMapper.astro
View file

@ -17,6 +17,7 @@ const {
IconCoffee,
IconDeviceWatch,
IconHeartHandshake,
IconCalendarPlus,
} = icons;
const { icon, className } = Astro.props;
const iconComponents = {
@ -35,6 +36,7 @@ const iconComponents = {
coffee: IconCoffee,
"device-watch": IconDeviceWatch,
"heart-handshake": IconHeartHandshake,
"calendar-plus": IconCalendarPlus,
};
const SelectedIcon = iconComponents[icon?.toLowerCase()] || null;
---

2
src/layouts/Layout.astro
View file

@ -97,7 +97,7 @@ const pageDescription = md(description);
{
isProduction && (
<>
<script is:inline defer data-domain="coryd.dev" src="/js/script.js" />
<script is:inline defer data-domain="coryd.dev" src="/scripts/util.js" />
<script is:inline defer>
window.plausible = window.plausible || function(...args) {
(window.plausible.q = window.plausible.q || []).push(args);

5
src/middleware.js
View file

@ -8,6 +8,9 @@ import { fetchShowByUrl } from "@utils/data/dynamic/showByUrl.js";
import { isbnRegex } from "@utils/helpers/media.js";
import { isExcludedPath } from "@utils/helpers/general.js";
import { CACHE_DURATION } from "@utils/constants/index.js";
import dotenvFlow from "dotenv-flow";
dotenvFlow.config();
let cachedGlobals = null;
let cachedNav = null;
@ -20,7 +23,7 @@ export async function onRequest(context, next) {
const { request, locals } = context;
try {
const runtimeEnv = locals.runtime?.env;
const runtimeEnv = process.env;
if (!runtimeEnv)
return new Response("Internal Server Error", { status: 500 });

10
src/pages/books/[isbn].astro
View file

@ -1,4 +1,5 @@
---
import { CacheHeaders, ONE_HOUR } from 'cdn-cache-control';
import Layout from "@layouts/Layout.astro";
import Warning from "@components/blocks/banners/Warning.astro";
import AssociatedMedia from "@components/blocks/AssociatedMedia.astro";
@ -12,6 +13,15 @@ const { book, globals } = await fetchGlobalData(Astro, Astro.url.pathname);
if (!book) return Astro.redirect("/404", 404);
const headers = new CacheHeaders()
.swr()
.ttl(ONE_HOUR)
.tag(['book', `book-${book.isbn}`]);
headers.forEach((value, key) => {
Astro.response.headers.set(key, value);
});
const alt = `${book.title}${book.author ? ` by ${book.author}` : ""}`;
const pageTitle = `${book.title} by ${book.author} / Books`;
const description =

3
src/pages/feeds/syndication.xml.js
View file

@ -1,6 +1,7 @@
import rss from "@astrojs/rss";
import { fetchGlobals } from "@utils/data/globals.js";
import { fetchSyndication } from "@utils/data/syndication.js";
import { htmlToText, sanitizeContent, md } from "@utils/helpers/general.js";
export const prerender = true;
@ -16,7 +17,7 @@ export async function GET() {
title: item.syndication.title,
pubDate: item.syndication.date,
link: item.syndication.url,
description: item.syndication.description,
description: htmlToText(md(item.syndication.description)),
})),
});
}

11
src/pages/music/artists/[slug].astro
View file

@ -1,4 +1,5 @@
---
import { CacheHeaders, ONE_HOUR } from 'cdn-cache-control';
import { parseISO, format } from "date-fns";
import Layout from "@layouts/Layout.astro";
import Modal from "@components/blocks/Modal.astro";
@ -8,11 +9,21 @@ import icons from "@cdransf/astro-tabler-icons";
import { fetchGlobalData } from "@utils/data/global/index.js";
import { parseCountries } from "@utils/helpers/media.js";
import { md } from "@utils/helpers/general.js";
import slugify from "slugify";
const { artist, globals } = await fetchGlobalData(Astro, Astro.url.pathname);
if (!artist) return Astro.redirect("/404", 404);
const headers = new CacheHeaders()
.swr()
.ttl(ONE_HOUR)
.tag(['artist', `artist-${slugify(artist.name, { lower: true })}`]);
headers.forEach((value, key) => {
Astro.response.headers.set(key, value);
});
const {
IconArrowLeft,
IconHeart,

12
src/pages/music/genres/[slug].astro
View file

@ -1,14 +1,26 @@
---
import { CacheHeaders, ONE_HOUR } from 'cdn-cache-control';
import Layout from "@layouts/Layout.astro";
import AssociatedMedia from "@components/blocks/AssociatedMedia.astro";
import icons from "@cdransf/astro-tabler-icons";
import { fetchGlobalData } from "@utils/data/global/index.js";
import { mediaLinks } from "@utils/helpers/media.js";
import { md } from "@utils/helpers/general.js";
import slugify from "slugify";
const { genre } = await fetchGlobalData(Astro, Astro.url.pathname);
if (!genre) return Astro.redirect("/404", 404);
const headers = new CacheHeaders()
.swr()
.ttl(ONE_HOUR)
.tag(['genre', `genre-${slugify(genre.name, { lower: true })}`]);
headers.forEach((value, key) => {
Astro.response.headers.set(key, value);
});
const { IconArrowLeft } = icons;
const artistCount = genre.artists?.length || 0;
const connectingWords = artistCount > 1 ? "artists are" : "artist is";

10
src/pages/watching/movies/[slug].astro
View file

@ -1,4 +1,5 @@
---
import { CacheHeaders, ONE_HOUR } from 'cdn-cache-control';
import { parseISO, format } from "date-fns";;
import Layout from "@layouts/Layout.astro";
import AssociatedMedia from "@components/blocks/AssociatedMedia.astro";
@ -11,6 +12,15 @@ const { globals, movie } = await fetchGlobalData(Astro, Astro.url.pathname);
if (!movie) return Astro.redirect("/404", 404);
const headers = new CacheHeaders()
.swr()
.ttl(ONE_HOUR)
.tag(['movie', `movie-${movie.id}`]);
headers.forEach((value, key) => {
Astro.response.headers.set(key, value);
});
const {
IconArrowLeft,
IconHeart,

10
src/pages/watching/shows/[slug].astro
View file

@ -1,4 +1,5 @@
---
import { CacheHeaders, ONE_HOUR } from 'cdn-cache-control';
import { parseISO, format } from "date-fns";
import Layout from "@layouts/Layout.astro";
import AssociatedMedia from "@components/blocks/AssociatedMedia.astro";
@ -11,6 +12,15 @@ const { globals, show } = await fetchGlobalData(Astro, Astro.url.pathname);
if (!show) return Astro.redirect("/404", 404);
const headers = new CacheHeaders()
.swr()
.ttl(ONE_HOUR)
.tag(['show', `show-${show.id}`]);
headers.forEach((value, key) => {
Astro.response.headers.set(key, value);
});
const {
IconArrowLeft,
IconHeart,

6
src/styles/base/index.css
View file

@ -119,6 +119,7 @@ ol {
.brand-github,
.brand-mastodon,
.brand-npm,
.calendar-plus,
.coffee,
.collected,
.concerts,
@ -153,6 +154,9 @@ ol {
&.brand-npm {
--section-color: var(--brand-npm);
}
&.calendar-plus {
--section-color: var(--brand-savvycal);
}
&.coffee {
--section-color: var(--brand-buy-me-a-coffee);
}
@ -507,4 +511,4 @@ pre code {
white-space: pre-wrap;
word-wrap: break-word;
overflow-wrap: break-word;
}
}

3
src/styles/base/vars.css
View file

@ -45,6 +45,7 @@
--brand-mastodon: light-dark(#563acc, #858afa);
--brand-npm: #cb3837;
--brand-rss: #f26522;
--brand-savvycal: light-dark(#00551f, #ff431f);
--article: light-dark(#007272, #00ffff);
--about: light-dark(#e4513a, #ff967d);
@ -159,4 +160,4 @@
/* input accent color */
accent-color: var(--accent-color);
}
}

261
src/utils/data/static/sitemapData.json
View file

@ -8637,151 +8637,46 @@
"loc": "https://coryd.dev/music/genres/alternative-metal"
},
{
"loc": "https://coryd.dev/watching/shows/17968"
},
{
"loc": "https://coryd.dev/watching/shows/71994"
},
{
"loc": "https://coryd.dev/watching/shows/19885"
},
{
"loc": "https://coryd.dev/watching/shows/210178"
},
{
"loc": "https://coryd.dev/watching/shows/119934"
},
{
"loc": "https://coryd.dev/watching/shows/113367"
},
{
"loc": "https://coryd.dev/watching/shows/122530"
},
{
"loc": "https://coryd.dev/watching/shows/104157"
},
{
"loc": "https://coryd.dev/watching/shows/61222"
},
{
"loc": "https://coryd.dev/watching/shows/138564"
},
{
"loc": "https://coryd.dev/watching/shows/62822"
},
{
"loc": "https://coryd.dev/watching/shows/1621"
"loc": "https://coryd.dev/watching/shows/94028"
},
{
"loc": "https://coryd.dev/watching/shows/1640"
},
{
"loc": "https://coryd.dev/watching/shows/157085"
},
{
"loc": "https://coryd.dev/watching/shows/2490"
},
{
"loc": "https://coryd.dev/watching/shows/85720"
},
{
"loc": "https://coryd.dev/watching/shows/119826"
},
{
"loc": "https://coryd.dev/watching/shows/75191"
},
{
"loc": "https://coryd.dev/watching/shows/1406"
},
{
"loc": "https://coryd.dev/watching/shows/712"
},
{
"loc": "https://coryd.dev/watching/shows/70391"
},
{
"loc": "https://coryd.dev/watching/shows/1920"
},
{
"loc": "https://coryd.dev/watching/shows/83631"
},
{
"loc": "https://coryd.dev/watching/shows/1405"
},
{
"loc": "https://coryd.dev/watching/shows/81241"
},
{
"loc": "https://coryd.dev/watching/shows/109939"
},
{
"loc": "https://coryd.dev/watching/shows/80707"
},
{
"loc": "https://coryd.dev/watching/shows/76887"
},
{
"loc": "https://coryd.dev/watching/shows/137437"
},
{
"loc": "https://coryd.dev/watching/shows/1414"
},
{
"loc": "https://coryd.dev/watching/shows/202557"
},
{
"loc": "https://coryd.dev/watching/shows/93784"
},
{
"loc": "https://coryd.dev/watching/shows/126254"
},
{
"loc": "https://coryd.dev/watching/shows/30991"
},
{
"loc": "https://coryd.dev/watching/shows/1398"
},
{
"loc": "https://coryd.dev/watching/shows/81239"
"loc": "https://coryd.dev/watching/shows/19885"
},
{
"loc": "https://coryd.dev/watching/shows/655"
},
{
"loc": "https://coryd.dev/watching/shows/79086"
"loc": "https://coryd.dev/watching/shows/93784"
},
{
"loc": "https://coryd.dev/watching/shows/80558"
"loc": "https://coryd.dev/watching/shows/17968"
},
{
"loc": "https://coryd.dev/watching/shows/15621"
"loc": "https://coryd.dev/watching/shows/1426"
},
{
"loc": "https://coryd.dev/watching/shows/136308"
},
{
"loc": "https://coryd.dev/watching/shows/157239"
},
{
"loc": "https://coryd.dev/watching/shows/233629"
"loc": "https://coryd.dev/watching/shows/30991"
},
{
"loc": "https://coryd.dev/watching/shows/76231"
},
{
"loc": "https://coryd.dev/watching/shows/47665"
"loc": "https://coryd.dev/watching/shows/126254"
},
{
"loc": "https://coryd.dev/watching/shows/1436"
},
{
"loc": "https://coryd.dev/watching/shows/111894"
"loc": "https://coryd.dev/watching/shows/65708"
},
{
"loc": "https://coryd.dev/watching/shows/157065"
},
{
"loc": "https://coryd.dev/watching/shows/1426"
"loc": "https://coryd.dev/watching/shows/202879"
},
{
"loc": "https://coryd.dev/watching/shows/157061"
},
{
"loc": "https://coryd.dev/watching/shows/114471"
@ -8793,32 +8688,140 @@
"loc": "https://coryd.dev/watching/shows/79649"
},
{
"loc": "https://coryd.dev/watching/shows/65708"
"loc": "https://coryd.dev/watching/shows/157239"
},
{
"loc": "https://coryd.dev/watching/shows/1436"
},
{
"loc": "https://coryd.dev/watching/shows/136308"
},
{
"loc": "https://coryd.dev/watching/shows/92553"
},
{
"loc": "https://coryd.dev/watching/shows/157061"
},
{
"loc": "https://coryd.dev/watching/shows/94028"
},
{
"loc": "https://coryd.dev/watching/shows/202879"
},
{
"loc": "https://coryd.dev/watching/shows/1107"
"loc": "https://coryd.dev/watching/shows/15621"
},
{
"loc": "https://coryd.dev/watching/shows/185"
},
{
"loc": "https://coryd.dev/watching/shows/136311"
"loc": "https://coryd.dev/watching/shows/109939"
},
{
"loc": "https://coryd.dev/watching/shows/62822"
},
{
"loc": "https://coryd.dev/watching/shows/1107"
},
{
"loc": "https://coryd.dev/watching/shows/210178"
},
{
"loc": "https://coryd.dev/watching/shows/1398"
},
{
"loc": "https://coryd.dev/watching/shows/137437"
},
{
"loc": "https://coryd.dev/watching/shows/61222"
},
{
"loc": "https://coryd.dev/watching/shows/1621"
},
{
"loc": "https://coryd.dev/watching/shows/138564"
},
{
"loc": "https://coryd.dev/watching/shows/111894"
},
{
"loc": "https://coryd.dev/watching/shows/1414"
},
{
"loc": "https://coryd.dev/watching/shows/47665"
},
{
"loc": "https://coryd.dev/watching/shows/119934"
},
{
"loc": "https://coryd.dev/watching/shows/104157"
},
{
"loc": "https://coryd.dev/watching/shows/119826"
},
{
"loc": "https://coryd.dev/watching/shows/1406"
},
{
"loc": "https://coryd.dev/watching/shows/113367"
},
{
"loc": "https://coryd.dev/watching/shows/71994"
},
{
"loc": "https://coryd.dev/watching/shows/157085"
},
{
"loc": "https://coryd.dev/watching/shows/2490"
},
{
"loc": "https://coryd.dev/watching/shows/75191"
},
{
"loc": "https://coryd.dev/watching/shows/712"
},
{
"loc": "https://coryd.dev/watching/shows/70391"
},
{
"loc": "https://coryd.dev/watching/shows/83631"
},
{
"loc": "https://coryd.dev/watching/shows/122530"
},
{
"loc": "https://coryd.dev/watching/shows/85720"
},
{
"loc": "https://coryd.dev/watching/shows/81241"
},
{
"loc": "https://coryd.dev/watching/shows/80707"
},
{
"loc": "https://coryd.dev/watching/shows/233629"
},
{
"loc": "https://coryd.dev/watching/shows/76887"
},
{
"loc": "https://coryd.dev/watching/shows/202557"
},
{
"loc": "https://coryd.dev/watching/shows/1920"
},
{
"loc": "https://coryd.dev/watching/shows/1405"
},
{
"loc": "https://coryd.dev/watching/shows/79086"
},
{
"loc": "https://coryd.dev/watching/shows/80558"
},
{
"loc": "https://coryd.dev/watching/shows/81239"
},
{
"loc": "https://coryd.dev/watching/shows/688"
},
{
"loc": "https://coryd.dev/watching/shows/157741"
},
{
"loc": "https://coryd.dev/watching/shows/136311"
},
{
"loc": "https://coryd.dev/watching/shows/125988"
},

40
workers/analytics/index.js
View file

@ -1,40 +0,0 @@
const scriptName = "/js/script.js";
const endpoint = "/api/event";
addEventListener("fetch", (event) => {
event.passThroughOnException();
event.respondWith(handleRequest(event));
});
async function handleRequest(event) {
const url = new URL(event.request.url);
const pathname = url.pathname;
if (pathname === scriptName) {
return getScript(event);
} else if (pathname === endpoint) {
return postData(event);
}
return new Response(null, { status: 404 });
}
async function getScript(event) {
const cache = caches.default;
let response = await cache.match(event.request);
if (!response) {
const scriptUrl =
"https://plausible.io/js/plausible.outbound-links.tagged-events.js";
response = await fetch(scriptUrl);
if (response.ok)
event.waitUntil(cache.put(event.request, response.clone()));
}
return response;
}
async function postData(event) {
const request = new Request(event.request);
request.headers.delete("cookie");
return await fetch("https://plausible.io/api/event", request);
}

13
workers/analytics/wrangler.template.toml
View file

@ -1,13 +0,0 @@
name = "analytics-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[env.production]
name = "analytics-worker-production"
routes = [
{ pattern = "coryd.dev/js/*", zone_id = "${CF_ZONE_ID}" },
{ pattern = "coryd.dev/api/event", zone_id = "${CF_ZONE_ID}" }
]

184
workers/artist-import/index.js
View file

@ -1,184 +0,0 @@
import slugify from "slugify";
import countries from "i18n-iso-countries";
countries.registerLocale(require("i18n-iso-countries/langs/en.json"));
function sanitizeMediaString(str) {
const sanitizedString = str
.normalize("NFD")
.replace(/[\u0300-\u036f\u2010\-\.\?\(\)\[\]\{\}]/g, "")
.replace(/\.{3}/g, "");
return slugify(sanitizedString, {
replacement: "-",
remove: /[#,&,+()$~%.'\":*?<>{}]/g,
lower: true,
});
}
export default {
async fetch(request, env) {
const directusUrl = env.DIRECTUS_URL;
const directusToken = env.DIRECTUS_API_TOKEN;
const artistImportToken = env.ARTIST_IMPORT_TOKEN;
const artistFlowID = env.ARTIST_FLOW_ID;
const albumFlowID = env.ALBUM_FLOW_ID;
const placeholderImageId = "4cef75db-831f-4f5d-9333-79eaa5bb55ee";
const requestUrl = new URL(request["url"]);
const providedToken = requestUrl.searchParams.get("token");
if (!providedToken || providedToken !== artistImportToken) return new Response("Unauthorized", { status: 401 });
async function saveToDirectus(endpoint, payload) {
const response = await fetch(`${directusUrl}/items/${endpoint}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${directusToken}`,
},
body: JSON.stringify(payload),
});
const data = await response.json();
if (!response.ok) {
throw new Error(
data["errors"]
? data["errors"][0]["message"]
: "Failed to save to Directus"
);
}
return data["data"];
}
async function findGenreIdByName(genreName) {
try {
const response = await fetch(
`${directusUrl}/items/genres?filter[name][_eq]=${encodeURIComponent(
genreName.toLowerCase()
)}`,
{ headers: { Authorization: `Bearer ${directusToken}` } }
);
const data = await response.json();
return data["data"].length > 0 ? data["data"][0]["id"] : null;
} catch (error) {
console.error("Error fetching genre ID:", error["message"]);
return null;
}
}
const artistId = requestUrl.searchParams.get("artist_id");
if (!artistId)
return new Response("artist_id parameter is required", { status: 400 });
let artistData;
try {
const artistResponse = await fetch(
`${directusUrl}/flows/trigger/${artistFlowID}?artist_id=${artistId}&import_token=${artistImportToken}`,
{ headers: { Authorization: `Bearer ${directusToken}` } }
);
artistData = await artistResponse.json();
artistData =
artistData["get_artist_data"]["data"]["MediaContainer"]["Metadata"][0];
} catch (error) {
console.error(
"Error fetching artist data from Directus flow:",
error["message"]
);
return new Response("Error fetching artist data", { status: 500 });
}
const artistName = artistData["title"] || "";
const artistKey = sanitizeMediaString(artistName);
const countryName = artistData["Country"]
? artistData["Country"][0]?.["tag"]
: "";
const countryIsoCode = countries.getAlpha2Code(countryName, "en") || "";
const slug = `/music/artists/${artistKey}-${countryName.toLowerCase()}`;
const description = artistData["summary"] || "";
const mbid = artistData["Guid"]?.[0]?.["id"]?.replace("mbid://", "") || "";
const genreNames = artistData["Genre"]
? artistData["Genre"].map((g) => g["tag"].toLowerCase())
: [];
let genreId = null;
for (const genreName of genreNames) {
genreId = await findGenreIdByName(genreName);
if (genreId) break;
}
const artistPayload = {
name: artistName,
name_string: artistName,
slug: slug,
description: description,
mbid: mbid,
tentative: true,
genres: genreId,
country: countryIsoCode,
art: placeholderImageId,
};
let insertedArtist;
try {
insertedArtist = await saveToDirectus("artists", artistPayload);
} catch (error) {
console.error("Error saving artist:", error["message"]);
return new Response("Error saving artist", { status: 500 });
}
let albumData;
try {
const albumResponse = await fetch(
`${directusUrl}/flows/trigger/${albumFlowID}?artist_id=${artistId}&import_token=${artistImportToken}`,
{ headers: { Authorization: `Bearer ${directusToken}` } }
);
albumData = await albumResponse.json();
albumData =
albumData["get_album_data"]["data"]["MediaContainer"]["Metadata"];
} catch (error) {
console.error(
"Error fetching album data from Directus flow:",
error["message"]
);
return new Response("Error fetching album data", { status: 500 });
}
for (const album of albumData) {
const albumName = album["title"] || "";
const albumKey = `${artistKey}-${sanitizeMediaString(albumName)}`;
const albumSlug = `/music/albums/${albumKey}`;
const albumDescription = album["summary"] || "";
const albumReleaseDate = album["originallyAvailableAt"] || "";
const albumReleaseYear = albumReleaseDate
? new Date(albumReleaseDate).getFullYear()
: null;
const albumGenres = album["Genre"]
? album["Genre"].map((g) => g["tag"])
: [];
const albumMbid =
album["Guid"]?.[0]?.["id"]?.replace("mbid://", "") || null;
const albumPayload = {
name: albumName,
key: albumKey,
slug: albumSlug,
mbid: albumMbid,
description: albumDescription,
release_year: albumReleaseYear,
artist: insertedArtist["id"],
artist_name: artistName,
genres: albumGenres,
art: placeholderImageId,
tentative: true,
};
try {
await saveToDirectus("albums", albumPayload);
} catch (error) {
console.error("Error saving album:", error["message"]);
}
}
return new Response("Artist and albums synced successfully", {
status: 200,
});
},
};

15
workers/artist-import/wrangler.template.toml
View file

@ -1,15 +0,0 @@
name = "import-artist-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[observability]
enabled = true
[env.production]
name = "import-artist-worker-production"
routes = [
{ pattern = "coryd.dev/api/import-artist*", zone_id = "${CF_ZONE_ID}" }
]

101
workers/contact/index.js
View file

@ -1,101 +0,0 @@
import { createClient } from "@supabase/supabase-js";
const RATE_LIMIT = 5;
const TIME_FRAME = 60 * 120 * 1000;
const ipSubmissions = new Map();
export default {
async fetch(request, env) {
if (request.method === "POST") {
const ip =
request.headers.get("CF-Connecting-IP") ||
request.headers.get("X-Forwarded-For") ||
request.headers.get("Remote-Addr");
const currentTime = Date.now();
if (!ipSubmissions.has(ip)) ipSubmissions.set(ip, []);
const submissions = ipSubmissions
.get(ip)
.filter((time) => currentTime - time < TIME_FRAME);
if (submissions.length >= RATE_LIMIT)
return Response.redirect("https://coryd.dev/rate-limit", 301);
submissions.push(currentTime);
ipSubmissions.set(ip, submissions);
try {
const formData = await request.formData();
const name = formData.get("name");
const email = formData.get("email");
const message = formData.get("message");
const hpName = formData.get("hp_name");
if (hpName) return new Response("Spam detected", { status: 400 });
if (!name || !email || !message)
return new Response("Invalid input", { status: 400 });
const emailDomain = email.split("@")[1].toLowerCase();
const supabaseUrl = env.SUPABASE_URL;
const supabaseKey = env.SUPABASE_KEY;
const supabase = createClient(supabaseUrl, supabaseKey);
const { data: blockedDomains, error: domainError } = await supabase
.from("blocked_domains")
.select("domain_name");
if (domainError)
throw new Error(
`Failed to fetch blocked domains: ${domainError.message}`
);
const domainList = blockedDomains.map((item) =>
item["domain_name"].toLowerCase()
);
if (domainList.includes(emailDomain))
return new Response("Email domain is blocked.", { status: 400 });
const { error } = await supabase
.from("contacts")
.insert([{ name, email, message, replied: false }]);
if (error) throw error;
const forwardEmailApiKey = env.FORWARDEMAIL_API_KEY;
const authHeader = "Basic " + btoa(`${forwardEmailApiKey}:`);
const emailData = new URLSearchParams({
from: `${name} <hi@admin.coryd.dev>`,
to: "hi@coryd.dev",
subject: `${message}`,
text: `Name: ${name}\nEmail: ${email}\nMessage: ${message}`,
replyTo: email,
}).toString();
const response = await fetch("https://api.forwardemail.net/v1/emails", {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
Authorization: authHeader,
},
body: emailData,
});
if (!response.ok) {
const errorText = await response.text();
console.error(
"Email API response error:",
response.status,
errorText
);
throw new Error(`Failed to send email: ${errorText}`);
}
return Response.redirect("https://coryd.dev/contact-success", 301);
} catch (error) {
console.error("Error:", error.message);
return Response.redirect("https://coryd.dev/broken", 301);
}
} else {
return Response.redirect("https://coryd.dev/not-allowed", 301);
}
},
};

12
workers/contact/wrangler.template.toml
View file

@ -1,12 +0,0 @@
name = "contact-form-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[env.production]
name = "contact-form-worker-production"
routes = [
{ pattern = "coryd.dev/api/contact", zone_id = "${CF_ZONE_ID}" }
]

21
workers/mastodon/wrangler.template.toml
View file

@ -1,21 +0,0 @@
name = "rss-to-mastodon-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[observability]
enabled = true
[[kv_namespaces]]
binding = "RSS_TO_MASTODON_NAMESPACE"
id = "${RSS_TO_MASTODON_KV_NAMESPACE_ID}"
[env.production]
name = "rss-to-mastodon-worker-production"
triggers = { crons = ["0 * * * *"] }
[[env.production.kv_namespaces]]
binding = "RSS_TO_MASTODON_NAMESPACE"
id = "${RSS_TO_MASTODON_KV_NAMESPACE_ID}"

20
workers/rebuild/index.js
View file

@ -1,20 +0,0 @@
export default {
async scheduled(event, env, ctx) {
const deployHookUrl = env.DEPLOY_HOOK_URL;
const response = await fetch(deployHookUrl, {
method: "POST",
});
if (!response.ok) {
const errorText = await response.text();
console.error(
`Error triggering deploy: ${response.statusText}`,
errorText
);
return;
}
console.log("Deploy triggered successfully");
},
};

10
workers/rebuild/wrangler.template.toml
View file

@ -1,10 +0,0 @@
name = "scheduled-rebuild-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[env.production]
name = "scheduled-rebuild-worker-production"
triggers = {crons = ["*/15 * * * *"]}

249
workers/scrobble/index.js
View file

@ -1,249 +0,0 @@
import { createClient } from "@supabase/supabase-js";
import slugify from "slugify";
const sanitizeMediaString = (str) => {
const sanitizedString = str
.normalize("NFD")
.replace(/[\u0300-\u036f\u2010\-\.\?\(\)\[\]\{\}]/g, "")
.replace(/\.{3}/g, "");
return slugify(sanitizedString, {
replacement: "-",
remove: /[#,&,+()$~%.'":*?<>{}]/g,
lower: true,
});
};
const sendEmail = async (subject, text, authHeader, maxRetries = 3) => {
const emailData = new URLSearchParams({
from: "coryd.dev <hi@admin.coryd.dev>",
to: "hi@coryd.dev",
subject: subject,
text: text,
}).toString();
let attempt = 0;
let success = false;
while (attempt < maxRetries && !success) {
attempt++;
try {
const response = await fetch("https://api.forwardemail.net/v1/emails", {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
Authorization: authHeader,
},
body: emailData,
});
if (!response.ok) {
const responseText = await response.text();
console.error(
`Attempt ${attempt}: Email API response error:`,
response.status,
responseText
);
throw new Error(`Failed to send email: ${responseText}`);
}
console.log("Email sent successfully on attempt", attempt);
success = true;
} catch (error) {
console.error(`Attempt ${attempt}: Error sending email:`, error.message);
if (attempt < maxRetries) {
console.log(
`Retrying email send (attempt ${attempt + 1}/${maxRetries})...`
);
} else {
console.error("All attempts to send email failed.");
}
}
}
return success;
};
export default {
async fetch(request, env) {
const supabaseUrl = env.SUPABASE_URL;
const supabaseKey = env.SUPABASE_KEY;
const FORWARDEMAIL_API_KEY = env.FORWARDEMAIL_API_KEY;
const ACCOUNT_ID_PLEX = env.ACCOUNT_ID_PLEX;
const supabase = createClient(supabaseUrl, supabaseKey);
const authHeader = "Basic " + btoa(`${FORWARDEMAIL_API_KEY}:`);
const url = new URL(request.url);
const params = url.searchParams;
const id = params.get("id");
if (!id)
return new Response(JSON.stringify({ status: "Bad request" }), {
headers: { "Content-Type": "application/json" },
});
if (id !== ACCOUNT_ID_PLEX)
return new Response(JSON.stringify({ status: "Forbidden" }), {
headers: { "Content-Type": "application/json" },
});
const contentType = request.headers.get("Content-Type") || "";
if (!contentType.includes("multipart/form-data"))
return new Response(
JSON.stringify({
status: "Bad request",
message: "Invalid Content-Type. Expected multipart/form-data.",
}),
{ headers: { "Content-Type": "application/json" } }
);
try {
const data = await request.formData();
const payload = JSON.parse(data.get("payload"));
if (payload?.event === "media.scrobble") {
const artistName = payload["Metadata"]["grandparentTitle"];
const albumName = payload["Metadata"]["parentTitle"];
const trackName = payload["Metadata"]["title"];
const listenedAt = Math.floor(Date.now() / 1000);
const artistKey = sanitizeMediaString(artistName);
const albumKey = `${artistKey}-${sanitizeMediaString(albumName)}`;
let { data: artistData, error: artistError } = await supabase
.from("artists")
.select("*")
.ilike("name_string", artistName)
.single();
if (artistError && artistError.code === "PGRST116") {
const { error: insertArtistError } = await supabase
.from("artists")
.insert([
{
mbid: null,
art: "4cef75db-831f-4f5d-9333-79eaa5bb55ee",
name: artistName,
slug: "/music",
tentative: true,
total_plays: 0,
},
]);
if (insertArtistError) {
console.error(
"Error inserting artist: ",
insertArtistError.message
);
return new Response(
JSON.stringify({
status: "error",
message: insertArtistError.message,
}),
{ headers: { "Content-Type": "application/json" } }
);
}
await sendEmail(
"New tentative artist record",
`A new tentative artist record was inserted:\n\nArtist: ${artistName}\nKey: ${artistKey}`,
authHeader
);
({ data: artistData, error: artistError } = await supabase
.from("artists")
.select("*")
.ilike("name_string", artistName)
.single());
}
if (artistError) {
console.error("Error fetching artist:", artistError.message);
return new Response(
JSON.stringify({ status: "error", message: artistError.message }),
{ headers: { "Content-Type": "application/json" } }
);
}
let { data: albumData, error: albumError } = await supabase
.from("albums")
.select("*")
.ilike("key", albumKey)
.single();
if (albumError && albumError.code === "PGRST116") {
const { error: insertAlbumError } = await supabase
.from("albums")
.insert([
{
mbid: null,
art: "4cef75db-831f-4f5d-9333-79eaa5bb55ee",
key: albumKey,
name: albumName,
tentative: true,
total_plays: 0,
artist: artistData.id,
},
]);
if (insertAlbumError) {
console.error("Error inserting album:", insertAlbumError.message);
return new Response(
JSON.stringify({
status: "error",
message: insertAlbumError.message,
}),
{ headers: { "Content-Type": "application/json" } }
);
}
await sendEmail(
"New tentative album record",
`A new tentative album record was inserted:\n\nAlbum: ${albumName}\nKey: ${albumKey}\nArtist: ${artistName}`,
authHeader
);
({ data: albumData, error: albumError } = await supabase
.from("albums")
.select("*")
.ilike("key", albumKey)
.single());
}
if (albumError) {
console.error("Error fetching album:", albumError.message);
return new Response(
JSON.stringify({ status: "error", message: albumError.message }),
{ headers: { "Content-Type": "application/json" } }
);
}
const { error: listenError } = await supabase.from("listens").insert([
{
artist_name: artistData["name_string"] || artistName,
album_name: albumData["name"] || albumName,
track_name: trackName,
listened_at: listenedAt,
album_key: albumKey,
},
]);
if (listenError) {
console.error("Error inserting listen:", listenError.message);
return new Response(
JSON.stringify({ status: "error", message: listenError.message }),
{ headers: { "Content-Type": "application/json" } }
);
}
console.log("Listen record inserted successfully");
}
return new Response(JSON.stringify({ status: "success" }), {
headers: { "Content-Type": "application/json" },
});
} catch (e) {
console.error("Error processing request:", e.message);
return new Response(
JSON.stringify({ status: "error", message: e.message }),
{ headers: { "Content-Type": "application/json" } }
);
}
},
};

15
workers/scrobble/wrangler.template.toml
View file

@ -1,15 +0,0 @@
name = "scrobble-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[observability]
enabled = true
[env.production]
name = "scrobble-worker-production"
routes = [
{ pattern = "coryd.dev/api/scrobble*", zone_id = "${CF_ZONE_ID}" }
]

44
workers/search/index.js
View file

@ -1,44 +0,0 @@
import { createClient } from "@supabase/supabase-js";
export default {
async fetch(request, env) {
const supabaseUrl = env.SUPABASE_URL;
const supabaseKey = env.SUPABASE_KEY;
const supabase = createClient(supabaseUrl, supabaseKey);
const { searchParams } = new URL(request.url);
const query = searchParams.get("q") || "";
const rawTypes = searchParams.getAll("type") || [];
const types = rawTypes.length > 0 ? rawTypes[0].split(",") : null;
const page = parseInt(searchParams.get("page") || "1", 10);
const pageSize = parseInt(searchParams.get("pageSize") || "10", 10);
const offset = (page - 1) * pageSize;
try {
const { data, error } = await supabase.rpc("search_optimized_index", {
search_query: query,
page_size: pageSize,
page_offset: offset,
types: types.length ? types : null,
});
if (error) {
console.error("Error fetching search data:", error);
return new Response(JSON.stringify({ results: [], total: 0 }), {
status: 500,
});
}
const total = data.length > 0 ? data[0].total_count : 0;
const results = data.map(({ total_count, ...item }) => item);
return new Response(JSON.stringify({ results, total, page, pageSize }), {
headers: { "Content-Type": "application/json" },
});
} catch (error) {
console.error("Unexpected error:", error);
return new Response("Internal Server Error", { status: 500 });
}
},
};

12
workers/search/wrangler.template.toml
View file

@ -1,12 +0,0 @@
name = "search-worker"
main = "./index.js"
compatibility_date = "2023-01-01"
account_id = "${CF_ACCOUNT_ID}"
workers_dev = true
[env.production]
name = "search-worker-production"
routes = [
{ pattern = "coryd.dev/api/search*", zone_id = "${CF_ZONE_ID}" },
]