@ekrist1/vulse 0.1.6-alpha.3 → 0.1.7-alpha.4

package/src/server/assets/live-preview-bridge.js

@@ -0,0 +1,535 @@
+// ../../node_modules/.pnpm/morphdom@2.7.8/node_modules/morphdom/dist/morphdom-esm.js
+var DOCUMENT_FRAGMENT_NODE = 11;
+function morphAttrs(fromNode, toNode) {
+  var toNodeAttrs = toNode.attributes;
+  var attr;
+  var attrName;
+  var attrNamespaceURI;
+  var attrValue;
+  var fromValue;
+  if (toNode.nodeType === DOCUMENT_FRAGMENT_NODE || fromNode.nodeType === DOCUMENT_FRAGMENT_NODE) {
+    return;
+  }
+  for (var i = toNodeAttrs.length - 1; i >= 0; i--) {
+    attr = toNodeAttrs[i];
+    attrName = attr.name;
+    attrNamespaceURI = attr.namespaceURI;
+    attrValue = attr.value;
+    if (attrNamespaceURI) {
+      attrName = attr.localName || attrName;
+      fromValue = fromNode.getAttributeNS(attrNamespaceURI, attrName);
+      if (fromValue !== attrValue) {
+        if (attr.prefix === "xmlns") {
+          attrName = attr.name;
+        }
+        fromNode.setAttributeNS(attrNamespaceURI, attrName, attrValue);
+      }
+    } else {
+      fromValue = fromNode.getAttribute(attrName);
+      if (fromValue !== attrValue) {
+        fromNode.setAttribute(attrName, attrValue);
+      }
+    }
+  }
+  var fromNodeAttrs = fromNode.attributes;
+  for (var d = fromNodeAttrs.length - 1; d >= 0; d--) {
+    attr = fromNodeAttrs[d];
+    attrName = attr.name;
+    attrNamespaceURI = attr.namespaceURI;
+    if (attrNamespaceURI) {
+      attrName = attr.localName || attrName;
+      if (!toNode.hasAttributeNS(attrNamespaceURI, attrName)) {
+        fromNode.removeAttributeNS(attrNamespaceURI, attrName);
+      }
+    } else {
+      if (!toNode.hasAttribute(attrName)) {
+        fromNode.removeAttribute(attrName);
+      }
+    }
+  }
+}
+var range;
+var NS_XHTML = "http://www.w3.org/1999/xhtml";
+var doc = typeof document === "undefined" ? void 0 : document;
+var HAS_TEMPLATE_SUPPORT = !!doc && "content" in doc.createElement("template");
+var HAS_RANGE_SUPPORT = !!doc && doc.createRange && "createContextualFragment" in doc.createRange();
+function createFragmentFromTemplate(str) {
+  var template = doc.createElement("template");
+  template.innerHTML = str;
+  return template.content.childNodes[0];
+}
+function createFragmentFromRange(str) {
+  if (!range) {
+    range = doc.createRange();
+    range.selectNode(doc.body);
+  }
+  var fragment = range.createContextualFragment(str);
+  return fragment.childNodes[0];
+}
+function createFragmentFromWrap(str) {
+  var fragment = doc.createElement("body");
+  fragment.innerHTML = str;
+  return fragment.childNodes[0];
+}
+function toElement(str) {
+  str = str.trim();
+  if (HAS_TEMPLATE_SUPPORT) {
+    return createFragmentFromTemplate(str);
+  } else if (HAS_RANGE_SUPPORT) {
+    return createFragmentFromRange(str);
+  }
+  return createFragmentFromWrap(str);
+}
+function compareNodeNames(fromEl, toEl) {
+  var fromNodeName = fromEl.nodeName;
+  var toNodeName = toEl.nodeName;
+  var fromCodeStart, toCodeStart;
+  if (fromNodeName === toNodeName) {
+    return true;
+  }
+  fromCodeStart = fromNodeName.charCodeAt(0);
+  toCodeStart = toNodeName.charCodeAt(0);
+  if (fromCodeStart <= 90 && toCodeStart >= 97) {
+    return fromNodeName === toNodeName.toUpperCase();
+  } else if (toCodeStart <= 90 && fromCodeStart >= 97) {
+    return toNodeName === fromNodeName.toUpperCase();
+  } else {
+    return false;
+  }
+}
+function createElementNS(name, namespaceURI) {
+  return !namespaceURI || namespaceURI === NS_XHTML ? doc.createElement(name) : doc.createElementNS(namespaceURI, name);
+}
+function moveChildren(fromEl, toEl) {
+  var curChild = fromEl.firstChild;
+  while (curChild) {
+    var nextChild = curChild.nextSibling;
+    toEl.appendChild(curChild);
+    curChild = nextChild;
+  }
+  return toEl;
+}
+function syncBooleanAttrProp(fromEl, toEl, name) {
+  if (fromEl[name] !== toEl[name]) {
+    fromEl[name] = toEl[name];
+    if (fromEl[name]) {
+      fromEl.setAttribute(name, "");
+    } else {
+      fromEl.removeAttribute(name);
+    }
+  }
+}
+var specialElHandlers = {
+  OPTION: function(fromEl, toEl) {
+    var parentNode = fromEl.parentNode;
+    if (parentNode) {
+      var parentName = parentNode.nodeName.toUpperCase();
+      if (parentName === "OPTGROUP") {
+        parentNode = parentNode.parentNode;
+        parentName = parentNode && parentNode.nodeName.toUpperCase();
+      }
+      if (parentName === "SELECT" && !parentNode.hasAttribute("multiple")) {
+        if (fromEl.hasAttribute("selected") && !toEl.selected) {
+          fromEl.setAttribute("selected", "selected");
+          fromEl.removeAttribute("selected");
+        }
+        parentNode.selectedIndex = -1;
+      }
+    }
+    syncBooleanAttrProp(fromEl, toEl, "selected");
+  },
+  /**
+   * The "value" attribute is special for the <input> element since it sets
+   * the initial value. Changing the "value" attribute without changing the
+   * "value" property will have no effect since it is only used to the set the
+   * initial value.  Similar for the "checked" attribute, and "disabled".
+   */
+  INPUT: function(fromEl, toEl) {
+    syncBooleanAttrProp(fromEl, toEl, "checked");
+    syncBooleanAttrProp(fromEl, toEl, "disabled");
+    if (fromEl.value !== toEl.value) {
+      fromEl.value = toEl.value;
+    }
+    if (!toEl.hasAttribute("value")) {
+      fromEl.removeAttribute("value");
+    }
+  },
+  TEXTAREA: function(fromEl, toEl) {
+    var newValue = toEl.value;
+    if (fromEl.value !== newValue) {
+      fromEl.value = newValue;
+    }
+    var firstChild = fromEl.firstChild;
+    if (firstChild) {
+      var oldValue = firstChild.nodeValue;
+      if (oldValue == newValue || !newValue && oldValue == fromEl.placeholder) {
+        return;
+      }
+      firstChild.nodeValue = newValue;
+    }
+  },
+  SELECT: function(fromEl, toEl) {
+    if (!toEl.hasAttribute("multiple")) {
+      var selectedIndex = -1;
+      var i = 0;
+      var curChild = fromEl.firstChild;
+      var optgroup;
+      var nodeName;
+      while (curChild) {
+        nodeName = curChild.nodeName && curChild.nodeName.toUpperCase();
+        if (nodeName === "OPTGROUP") {
+          optgroup = curChild;
+          curChild = optgroup.firstChild;
+          if (!curChild) {
+            curChild = optgroup.nextSibling;
+            optgroup = null;
+          }
+        } else {
+          if (nodeName === "OPTION") {
+            if (curChild.hasAttribute("selected")) {
+              selectedIndex = i;
+              break;
+            }
+            i++;
+          }
+          curChild = curChild.nextSibling;
+          if (!curChild && optgroup) {
+            curChild = optgroup.nextSibling;
+            optgroup = null;
+          }
+        }
+      }
+      fromEl.selectedIndex = selectedIndex;
+    }
+  }
+};
+var ELEMENT_NODE = 1;
+var DOCUMENT_FRAGMENT_NODE$1 = 11;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
+function noop() {
+}
+function defaultGetNodeKey(node) {
+  if (node) {
+    return node.getAttribute && node.getAttribute("id") || node.id;
+  }
+}
+function morphdomFactory(morphAttrs2) {
+  return function morphdom2(fromNode, toNode, options) {
+    if (!options) {
+      options = {};
+    }
+    if (typeof toNode === "string") {
+      if (fromNode.nodeName === "#document" || fromNode.nodeName === "HTML") {
+        var toNodeHtml = toNode;
+        toNode = doc.createElement("html");
+        toNode.innerHTML = toNodeHtml;
+      } else if (fromNode.nodeName === "BODY") {
+        var toNodeBody = toNode;
+        toNode = doc.createElement("html");
+        toNode.innerHTML = toNodeBody;
+        var bodyElement = toNode.querySelector("body");
+        if (bodyElement) {
+          toNode = bodyElement;
+        }
+      } else {
+        toNode = toElement(toNode);
+      }
+    } else if (toNode.nodeType === DOCUMENT_FRAGMENT_NODE$1) {
+      toNode = toNode.firstElementChild;
+    }
+    var getNodeKey = options.getNodeKey || defaultGetNodeKey;
+    var onBeforeNodeAdded = options.onBeforeNodeAdded || noop;
+    var onNodeAdded = options.onNodeAdded || noop;
+    var onBeforeElUpdated = options.onBeforeElUpdated || noop;
+    var onElUpdated = options.onElUpdated || noop;
+    var onBeforeNodeDiscarded = options.onBeforeNodeDiscarded || noop;
+    var onNodeDiscarded = options.onNodeDiscarded || noop;
+    var onBeforeElChildrenUpdated = options.onBeforeElChildrenUpdated || noop;
+    var skipFromChildren = options.skipFromChildren || noop;
+    var addChild = options.addChild || function(parent, child) {
+      return parent.appendChild(child);
+    };
+    var childrenOnly = options.childrenOnly === true;
+    var fromNodesLookup = /* @__PURE__ */ Object.create(null);
+    var keyedRemovalList = [];
+    function addKeyedRemoval(key) {
+      keyedRemovalList.push(key);
+    }
+    function walkDiscardedChildNodes(node, skipKeyedNodes) {
+      if (node.nodeType === ELEMENT_NODE) {
+        var curChild = node.firstChild;
+        while (curChild) {
+          var key = void 0;
+          if (skipKeyedNodes && (key = getNodeKey(curChild))) {
+            addKeyedRemoval(key);
+          } else {
+            onNodeDiscarded(curChild);
+            if (curChild.firstChild) {
+              walkDiscardedChildNodes(curChild, skipKeyedNodes);
+            }
+          }
+          curChild = curChild.nextSibling;
+        }
+      }
+    }
+    function removeNode(node, parentNode, skipKeyedNodes) {
+      if (onBeforeNodeDiscarded(node) === false) {
+        return;
+      }
+      if (parentNode) {
+        parentNode.removeChild(node);
+      }
+      onNodeDiscarded(node);
+      walkDiscardedChildNodes(node, skipKeyedNodes);
+    }
+    function indexTree(node) {
+      if (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE$1) {
+        var curChild = node.firstChild;
+        while (curChild) {
+          var key = getNodeKey(curChild);
+          if (key) {
+            fromNodesLookup[key] = curChild;
+          }
+          indexTree(curChild);
+          curChild = curChild.nextSibling;
+        }
+      }
+    }
+    indexTree(fromNode);
+    function handleNodeAdded(el) {
+      onNodeAdded(el);
+      var curChild = el.firstChild;
+      while (curChild) {
+        var nextSibling = curChild.nextSibling;
+        var key = getNodeKey(curChild);
+        if (key) {
+          var unmatchedFromEl = fromNodesLookup[key];
+          if (unmatchedFromEl && compareNodeNames(curChild, unmatchedFromEl)) {
+            curChild.parentNode.replaceChild(unmatchedFromEl, curChild);
+            morphEl(unmatchedFromEl, curChild);
+          } else {
+            handleNodeAdded(curChild);
+          }
+        } else {
+          handleNodeAdded(curChild);
+        }
+        curChild = nextSibling;
+      }
+    }
+    function cleanupFromEl(fromEl, curFromNodeChild, curFromNodeKey) {
+      while (curFromNodeChild) {
+        var fromNextSibling = curFromNodeChild.nextSibling;
+        if (curFromNodeKey = getNodeKey(curFromNodeChild)) {
+          addKeyedRemoval(curFromNodeKey);
+        } else {
+          removeNode(
+            curFromNodeChild,
+            fromEl,
+            true
+            /* skip keyed nodes */
+          );
+        }
+        curFromNodeChild = fromNextSibling;
+      }
+    }
+    function morphEl(fromEl, toEl, childrenOnly2) {
+      var toElKey = getNodeKey(toEl);
+      if (toElKey) {
+        delete fromNodesLookup[toElKey];
+      }
+      if (!childrenOnly2) {
+        var beforeUpdateResult = onBeforeElUpdated(fromEl, toEl);
+        if (beforeUpdateResult === false) {
+          return;
+        } else if (beforeUpdateResult instanceof HTMLElement) {
+          fromEl = beforeUpdateResult;
+          indexTree(fromEl);
+        }
+        morphAttrs2(fromEl, toEl);
+        onElUpdated(fromEl);
+        if (onBeforeElChildrenUpdated(fromEl, toEl) === false) {
+          return;
+        }
+      }
+      if (fromEl.nodeName !== "TEXTAREA") {
+        morphChildren(fromEl, toEl);
+      } else {
+        specialElHandlers.TEXTAREA(fromEl, toEl);
+      }
+    }
+    function morphChildren(fromEl, toEl) {
+      var skipFrom = skipFromChildren(fromEl, toEl);
+      var curToNodeChild = toEl.firstChild;
+      var curFromNodeChild = fromEl.firstChild;
+      var curToNodeKey;
+      var curFromNodeKey;
+      var fromNextSibling;
+      var toNextSibling;
+      var matchingFromEl;
+      outer: while (curToNodeChild) {
+        toNextSibling = curToNodeChild.nextSibling;
+        curToNodeKey = getNodeKey(curToNodeChild);
+        while (!skipFrom && curFromNodeChild) {
+          fromNextSibling = curFromNodeChild.nextSibling;
+          if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {
+            curToNodeChild = toNextSibling;
+            curFromNodeChild = fromNextSibling;
+            continue outer;
+          }
+          curFromNodeKey = getNodeKey(curFromNodeChild);
+          var curFromNodeType = curFromNodeChild.nodeType;
+          var isCompatible = void 0;
+          if (curFromNodeType === curToNodeChild.nodeType) {
+            if (curFromNodeType === ELEMENT_NODE) {
+              if (curToNodeKey) {
+                if (curToNodeKey !== curFromNodeKey) {
+                  if (matchingFromEl = fromNodesLookup[curToNodeKey]) {
+                    if (fromNextSibling === matchingFromEl) {
+                      isCompatible = false;
+                    } else {
+                      fromEl.insertBefore(matchingFromEl, curFromNodeChild);
+                      if (curFromNodeKey) {
+                        addKeyedRemoval(curFromNodeKey);
+                      } else {
+                        removeNode(
+                          curFromNodeChild,
+                          fromEl,
+                          true
+                          /* skip keyed nodes */
+                        );
+                      }
+                      curFromNodeChild = matchingFromEl;
+                      curFromNodeKey = getNodeKey(curFromNodeChild);
+                    }
+                  } else {
+                    isCompatible = false;
+                  }
+                }
+              } else if (curFromNodeKey) {
+                isCompatible = false;
+              }
+              isCompatible = isCompatible !== false && compareNodeNames(curFromNodeChild, curToNodeChild);
+              if (isCompatible) {
+                morphEl(curFromNodeChild, curToNodeChild);
+              }
+            } else if (curFromNodeType === TEXT_NODE || curFromNodeType == COMMENT_NODE) {
+              isCompatible = true;
+              if (curFromNodeChild.nodeValue !== curToNodeChild.nodeValue) {
+                curFromNodeChild.nodeValue = curToNodeChild.nodeValue;
+              }
+            }
+          }
+          if (isCompatible) {
+            curToNodeChild = toNextSibling;
+            curFromNodeChild = fromNextSibling;
+            continue outer;
+          }
+          if (curFromNodeKey) {
+            addKeyedRemoval(curFromNodeKey);
+          } else {
+            removeNode(
+              curFromNodeChild,
+              fromEl,
+              true
+              /* skip keyed nodes */
+            );
+          }
+          curFromNodeChild = fromNextSibling;
+        }
+        if (curToNodeKey && (matchingFromEl = fromNodesLookup[curToNodeKey]) && compareNodeNames(matchingFromEl, curToNodeChild)) {
+          if (!skipFrom) {
+            addChild(fromEl, matchingFromEl);
+          }
+          morphEl(matchingFromEl, curToNodeChild);
+        } else {
+          var onBeforeNodeAddedResult = onBeforeNodeAdded(curToNodeChild);
+          if (onBeforeNodeAddedResult !== false) {
+            if (onBeforeNodeAddedResult) {
+              curToNodeChild = onBeforeNodeAddedResult;
+            }
+            if (curToNodeChild.actualize) {
+              curToNodeChild = curToNodeChild.actualize(fromEl.ownerDocument || doc);
+            }
+            addChild(fromEl, curToNodeChild);
+            handleNodeAdded(curToNodeChild);
+          }
+        }
+        curToNodeChild = toNextSibling;
+        curFromNodeChild = fromNextSibling;
+      }
+      cleanupFromEl(fromEl, curFromNodeChild, curFromNodeKey);
+      var specialElHandler = specialElHandlers[fromEl.nodeName];
+      if (specialElHandler) {
+        specialElHandler(fromEl, toEl);
+      }
+    }
+    var morphedNode = fromNode;
+    var morphedNodeType = morphedNode.nodeType;
+    var toNodeType = toNode.nodeType;
+    if (!childrenOnly) {
+      if (morphedNodeType === ELEMENT_NODE) {
+        if (toNodeType === ELEMENT_NODE) {
+          if (!compareNodeNames(fromNode, toNode)) {
+            onNodeDiscarded(fromNode);
+            morphedNode = moveChildren(fromNode, createElementNS(toNode.nodeName, toNode.namespaceURI));
+          }
+        } else {
+          morphedNode = toNode;
+        }
+      } else if (morphedNodeType === TEXT_NODE || morphedNodeType === COMMENT_NODE) {
+        if (toNodeType === morphedNodeType) {
+          if (morphedNode.nodeValue !== toNode.nodeValue) {
+            morphedNode.nodeValue = toNode.nodeValue;
+          }
+          return morphedNode;
+        } else {
+          morphedNode = toNode;
+        }
+      }
+    }
+    if (morphedNode === toNode) {
+      onNodeDiscarded(fromNode);
+    } else {
+      if (toNode.isSameNode && toNode.isSameNode(morphedNode)) {
+        return;
+      }
+      morphEl(morphedNode, toNode, childrenOnly);
+      if (keyedRemovalList) {
+        for (var i = 0, len = keyedRemovalList.length; i < len; i++) {
+          var elToRemove = fromNodesLookup[keyedRemovalList[i]];
+          if (elToRemove) {
+            removeNode(elToRemove, elToRemove.parentNode, false);
+          }
+        }
+      }
+    }
+    if (!childrenOnly && morphedNode !== fromNode && fromNode.parentNode) {
+      if (morphedNode.actualize) {
+        morphedNode = morphedNode.actualize(fromNode.ownerDocument || doc);
+      }
+      fromNode.parentNode.replaceChild(morphedNode, fromNode);
+    }
+    return morphedNode;
+  };
+}
+var morphdom = morphdomFactory(morphAttrs);
+var morphdom_esm_default = morphdom;
+
+// src/client/live-preview-bridge.ts
+var ROOT = document.documentElement.dataset.vulsePreviewRoot ?? "main";
+window.addEventListener("message", async (event) => {
+  if (event.origin !== window.location.origin) return;
+  if (event.data?.name !== "vulse.preview.updated") return;
+  const res = await fetch(window.location.href, {
+    cache: "no-store",
+    credentials: "include",
+    headers: { Accept: "text/html" }
+  });
+  if (!res.ok) return;
+  const html = await res.text();
+  const doc2 = new DOMParser().parseFromString(html, "text/html");
+  const from = doc2.querySelector(ROOT);
+  const to = document.querySelector(ROOT);
+  if (from && to) morphdom_esm_default(to, from, { childrenOnly: true });
+});

package/src/server/better-auth.ts

@@ -0,0 +1,82 @@
+import { betterAuth } from 'better-auth'
+import { drizzleAdapter } from 'better-auth/adapters/drizzle'
+import type { VulseDb } from '../core/db.js'
+import * as schema from '../core/schema.js'
+import { SettingsRepo } from '../core/repos/settings.js'
+import { runAuthUserAfterCreateHooks, runAuthUserBeforeCreateHooks } from './plugins.js'
+import type { AuthUserCreateInput } from '../core/plugins/definition.js'
+import { sendEmail, type EmailEnv } from './email.js'
+
+export interface AuthConfig {
+  baseURL: string
+  secret: string
+  /** Override settings row (tests/cron). */
+  allowSignUp?: boolean
+  env?: Record<string, unknown>
+}
+
+function emailDomain(email: string): string | null {
+  return email.split('@')[1]?.toLowerCase() ?? null
+}
+
+export async function createAuth(db: VulseDb, config: AuthConfig) {
+  const settings = new SettingsRepo(db)
+  const allowSignUp = config.allowSignUp ?? (await settings.get<boolean>('allowMemberSignUp')) ?? false
+  const allowedDomains = (await settings.get<string[]>('allowedSignUpDomains')) ?? []
+  const pluginEnv = config.env
+
+  return betterAuth({
+    baseURL: config.baseURL,
+    secret: config.secret,
+    database: drizzleAdapter(db, { provider: 'sqlite', schema }),
+    emailAndPassword: {
+      enabled: true,
+      autoSignIn: true,
+      disableSignUp: !allowSignUp,
+      sendResetPassword: async ({ user, url }) => {
+        const emailEnv = pluginEnv as EmailEnv | undefined
+        void sendEmail(emailEnv ?? {}, {
+          to: user.email,
+          subject: 'Reset your password',
+          body: `Click the link to reset your password:\n\n${url}\n\nIf you did not request this, you can ignore this email.`,
+        })
+      },
+    },
+    user: {
+      additionalFields: {
+        role: { type: 'string', defaultValue: 'member', input: false },
+        displayName: { type: 'string', required: false },
+      },
+    },
+    session: {
+      cookieCache: { enabled: true, maxAge: 5 * 60 },
+    },
+    databaseHooks: {
+      user: {
+        create: {
+          before: async (user) => {
+            const email = typeof user.email === 'string' ? user.email : ''
+            const domain = emailDomain(email)
+            if (allowedDomains.length > 0 && (!domain || !allowedDomains.includes(domain))) {
+              throw new Error('Email domain not allowed')
+            }
+
+            const nextUser = await runAuthUserBeforeCreateHooks({
+              user: user as AuthUserCreateInput,
+            }, pluginEnv)
+            if (nextUser === false) return false
+            if (nextUser) return { data: nextUser }
+            return undefined
+          },
+          after: async (user) => {
+            await runAuthUserAfterCreateHooks({
+              user: user as AuthUserCreateInput,
+            }, pluginEnv)
+          },
+        },
+      },
+    },
+  })
+}
+
+export type Auth = Awaited<ReturnType<typeof createAuth>>

package/src/server/cf-images.ts

@@ -0,0 +1,34 @@
+const DEFAULT_VARIANTS = ['thumbnail', 'card', 'hero', 'og'] as const
+export type Variant = typeof DEFAULT_VARIANTS[number]
+
+export interface CfImagesConfig {
+  accountHash?: string
+  token?: string
+}
+
+export function isImagesEnabled(cfg: CfImagesConfig): boolean {
+  return !!cfg.accountHash
+}
+
+export function buildDeliveryUrl(cfg: CfImagesConfig, imageId: string, variant: Variant | string = 'card'): string | null {
+  if (!cfg.accountHash) return null
+  return `https://imagedelivery.net/${cfg.accountHash}/${imageId}/${variant}`
+}
+
+/** Called on first migration: ensures default variants exist via the CF Images API. */
+export async function registerDefaultVariants(cfg: CfImagesConfig): Promise<void> {
+  if (!cfg.token || !cfg.accountHash) return
+  const variants = [
+    { id: 'thumbnail', options: { fit: 'cover', width: 160, height: 160 } },
+    { id: 'card', options: { fit: 'cover', width: 800, height: 450 } },
+    { id: 'hero', options: { fit: 'scale-down', width: 1600 } },
+    { id: 'og', options: { fit: 'cover', width: 1200, height: 630 } },
+  ]
+  for (const v of variants) {
+    await fetch(`https://api.cloudflare.com/client/v4/accounts/${cfg.accountHash}/images/v1/variants`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${cfg.token}`, 'content-type': 'application/json' },
+      body: JSON.stringify(v),
+    }).catch(() => {})
+  }
+}

package/src/server/cron.ts

@@ -0,0 +1,37 @@
+import { createDb } from '../core/db.js'
+import { PreviewSessionsRepo } from '../core/repos/preview-sessions.js'
+import { mediaRoutes } from './routes/media.js'
+import { purgeExpiredFormUploadDrafts } from './routes/form-upload.js'
+import { createAuth } from './better-auth.js'
+
+export interface CronEnv {
+  DB: D1Database
+  BUCKET: R2Bucket
+  CF_IMAGES_ACCOUNT_HASH?: string
+  CF_IMAGES_TOKEN?: string
+  BETTER_AUTH_SECRET: string
+}
+
+export async function vulseScheduled(env: CronEnv): Promise<void> {
+  const db = createDb(env.DB)
+  const auth = await createAuth(db, {
+    baseURL: 'http://localhost',
+    secret: env.BETTER_AUTH_SECRET,
+    allowSignUp: false,
+  })
+  const routes = mediaRoutes(db, auth, {
+    bucket: env.BUCKET,
+    cfImages: {
+      ...(env.CF_IMAGES_ACCOUNT_HASH ? { accountHash: env.CF_IMAGES_ACCOUNT_HASH } : {}),
+      ...(env.CF_IMAGES_TOKEN ? { token: env.CF_IMAGES_TOKEN } : {}),
+    },
+  })
+  const mediaResult = await routes.purge()
+  console.log(`[vulse-cron] purged ${mediaResult.purged} media row(s)`)
+
+  const draftResult = await purgeExpiredFormUploadDrafts(db, env.BUCKET)
+  console.log(`[vulse-cron] purged ${draftResult.purged} form upload draft(s)`)
+
+  const previewResult = await new PreviewSessionsRepo(db).purgeExpired(new Date())
+  console.log(`[vulse-cron] purged ${previewResult} preview session(s)`)
+}