@jant/core 0.3.39 → 0.3.42

package/bin/lib/media-upload.js

@@ -0,0 +1,206 @@
+import { basename, extname } from "node:path";
+import { readFile } from "node:fs/promises";
+import { requestJson, requestRaw, resolveRequestUrl } from "./http-api.js";
+
+const MIME_TYPES = {
+  ".avif": "image/avif",
+  ".csv": "text/csv",
+  ".gif": "image/gif",
+  ".heic": "image/heic",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".md": "text/markdown",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+};
+
+function inferContentType(filePath, explicitContentType) {
+  const trimmed = explicitContentType?.trim();
+  if (trimmed) {
+    return trimmed;
+  }
+
+  const ext = extname(filePath).toLowerCase();
+  const inferred = MIME_TYPES[ext];
+  if (inferred) {
+    return inferred;
+  }
+
+  throw new Error(
+    `Couldn't infer a content type for ${filePath}. Pass --content-type explicitly.`,
+  );
+}
+
+function buildCompletePayload(metadata, parts) {
+  return {
+    ...(metadata.width === undefined ? {} : { width: metadata.width }),
+    ...(metadata.height === undefined ? {} : { height: metadata.height }),
+    ...(metadata.durationSeconds === undefined
+      ? {}
+      : { durationSeconds: metadata.durationSeconds }),
+    ...(metadata.blurhash === undefined ? {} : { blurhash: metadata.blurhash }),
+    ...(metadata.waveform === undefined ? {} : { waveform: metadata.waveform }),
+    ...(metadata.summary === undefined ? {} : { summary: metadata.summary }),
+    ...(metadata.chars === undefined ? {} : { chars: metadata.chars }),
+    ...(parts ? { parts } : {}),
+  };
+}
+
+async function uploadTransportBytes({ fileBytes, siteUrl, token, transport }) {
+  switch (transport.kind) {
+    case "relay": {
+      await requestRaw({
+        body: fileBytes,
+        method: "PUT",
+        token,
+        url: resolveRequestUrl(siteUrl, transport.url),
+      });
+      return undefined;
+    }
+    case "put": {
+      await requestRaw({
+        body: fileBytes,
+        headers: transport.headers,
+        method: transport.method,
+        url: transport.url,
+      });
+      return undefined;
+    }
+    case "multipartRelay": {
+      const parts = [];
+
+      for (
+        let offset = 0, partNumber = 1;
+        offset < fileBytes.byteLength;
+        offset += transport.partSize, partNumber += 1
+      ) {
+        const partUrl = new URL(resolveRequestUrl(siteUrl, transport.url));
+        partUrl.searchParams.set("partNumber", String(partNumber));
+        const chunk = fileBytes.subarray(offset, offset + transport.partSize);
+        const { json } = await requestRaw({
+          body: chunk,
+          method: "PUT",
+          token,
+          url: partUrl.toString(),
+        });
+
+        parts.push(json);
+      }
+
+      return parts;
+    }
+    default:
+      throw new Error(`Unsupported upload transport: ${transport.kind}`);
+  }
+}
+
+export async function uploadMediaFile({
+  alt,
+  blurhash,
+  chars,
+  contentType,
+  durationSeconds,
+  filePath,
+  height,
+  posterPath,
+  siteUrl,
+  summary,
+  token,
+  waveform,
+  width,
+}) {
+  const fileBytes = await readFile(filePath);
+  const resolvedContentType = inferContentType(filePath, contentType);
+  const filename = basename(filePath);
+  const init = await requestJson({
+    siteUrl,
+    path: "/api/uploads/init",
+    method: "POST",
+    token,
+    body: {
+      filename,
+      contentType: resolvedContentType,
+      size: fileBytes.byteLength,
+    },
+  });
+
+  if (
+    !init ||
+    typeof init !== "object" ||
+    !("id" in init) ||
+    !("transport" in init) ||
+    !init.transport ||
+    typeof init.transport !== "object" ||
+    !("kind" in init.transport)
+  ) {
+    throw new Error("Upload init returned an unexpected response.");
+  }
+
+  const parts = await uploadTransportBytes({
+    fileBytes,
+    siteUrl,
+    token,
+    transport: init.transport,
+  });
+
+  if (posterPath?.trim()) {
+    const posterBytes = await readFile(posterPath);
+    await requestRaw({
+      body: posterBytes,
+      method: "PUT",
+      token,
+      url: resolveRequestUrl(siteUrl, `/api/uploads/${init.id}/poster`),
+    });
+  }
+
+  const complete = await requestJson({
+    siteUrl,
+    path: `/api/uploads/${init.id}/complete`,
+    method: "POST",
+    token,
+    body: buildCompletePayload(
+      {
+        alt,
+        blurhash,
+        chars,
+        durationSeconds,
+        height,
+        summary,
+        waveform,
+        width,
+      },
+      Array.isArray(parts) ? parts : undefined,
+    ),
+  });
+
+  if (!complete || typeof complete !== "object" || !("id" in complete)) {
+    throw new Error("Upload complete returned an unexpected response.");
+  }
+
+  if (alt !== undefined) {
+    return requestJson({
+      siteUrl,
+      path: `/api/upload/${complete.id}`,
+      method: "PATCH",
+      token,
+      body: {
+        alt,
+      },
+    });
+  }
+
+  return requestJson({
+    siteUrl,
+    path: `/api/upload/${complete.id}`,
+    token,
+  });
+}

package/bin/lib/migration-runner.js

@@ -309,3 +309,67 @@ export function applyNodeBackfills(sqlite) {
     tableName: DEFAULT_DATA_MIGRATION_TABLE,
   });
 }
+
+function createPgTrackingTableSql(tableName) {
+  const table = quoteIdentifier(tableName);
+  return `
+    CREATE TABLE IF NOT EXISTS ${table} (
+      "id" SERIAL PRIMARY KEY,
+      "name" TEXT UNIQUE NOT NULL,
+      "applied_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+    );
+  `;
+}
+
+function createPgSqlRunner(pool) {
+  return {
+    async execute(sql) {
+      await pool.query(sql);
+    },
+    async query(sql) {
+      const result = await pool.query(sql);
+      return result.rows;
+    },
+  };
+}
+
+export async function applyPgBackfills(pool) {
+  const runner = createPgSqlRunner(pool);
+  const files = listBackfillFiles(resolveBundledBackfillsDir());
+  if (files.length === 0) {
+    console.log("No data backfills to apply.");
+    return 0;
+  }
+
+  const tableName = DEFAULT_DATA_MIGRATION_TABLE;
+  await runner.execute(createPgTrackingTableSql(tableName));
+  const table = quoteIdentifier(tableName);
+  const applied = await runner.query(
+    `SELECT "name" FROM ${table} ORDER BY "id"`,
+  );
+  const appliedNames = new Set(applied.map((row) => String(row.name)));
+  const pendingFiles = files.filter((file) => !appliedNames.has(file.name));
+
+  if (pendingFiles.length === 0) {
+    console.log("No data backfills to apply.");
+    return 0;
+  }
+
+  console.log(`Applying data backfills (${pendingFiles.length} pending)...`);
+
+  for (const [index, file] of pendingFiles.entries()) {
+    try {
+      const sql = readNormalizedSqlFile(file.path);
+      const trackingSql = `INSERT INTO ${table} ("name") VALUES (${quoteString(file.name)});`;
+      await runner.execute(`${sql}\n${trackingSql}`);
+      console.log(`[${index + 1}/${pendingFiles.length}] ${file.name} ✅`);
+    } catch (error) {
+      console.log(`[${index + 1}/${pendingFiles.length}] ${file.name} ❌`);
+      throw new Error(`Failed to apply ${file.name}: ${error.message}`, {
+        cause: error,
+      });
+    }
+  }
+
+  return pendingFiles.length;
+}

package/bin/lib/runtime-target.js

@@ -1,6 +1,7 @@
 export function resolveCliRuntime(values, env = process.env) {
-  if (values.local && values.remote) {
-    throw new Error("Choose either --local or --remote, not both.");
+  const flags = [values.local, values.remote, values.node].filter(Boolean);
+  if (flags.length > 1) {
+    throw new Error("Choose only one of --local, --remote, or --node.");
   }
 
   if (values.remote) {
@@ -11,6 +12,10 @@ export function resolveCliRuntime(values, env = process.env) {
     return "d1-local";
   }
 
+  if (values.node) {
+    return "node";
+  }
+
   if (
     (typeof env.DATABASE_URL === "string" && env.DATABASE_URL.length > 0) ||
     (typeof env.DATA_DIR === "string" && env.DATA_DIR.length > 0)

package/bin/lib/site-media-parser.js

@@ -1110,34 +1110,89 @@ function parseAttachmentBlockHtml(html) {
   return attachments;
 }
 
+/**
+ * Checks whether an HTML string looks like the start of a
+ * `<div data-jant-node="attachments">` block (possibly incomplete due to
+ * blank-line splitting in the markdown parser).
+ */
+function looksLikeAttachmentBlockOpener(html) {
+  const fragment = parseHtmlFragment(html);
+  const rootNodes = (fragment.childNodes || []).filter(
+    (node) => !isWhitespaceHtmlNode(node),
+  );
+  return rootNodes.length >= 1 && isAttachmentRoot(rootNodes[0]);
+}
+
 export function extractAttachmentBlocks(markdown) {
   const tree = parseMarkdown(markdown);
   const attachments = [];
   const removalPatches = [];
 
+  // Collect all HTML nodes from the tree so we can look ahead when the
+  // markdown parser splits a single HTML block across blank lines.
+  const htmlNodes = [];
   visit(tree, "html", (node) => {
-    if (typeof node.value !== "string") {
-      return;
+    if (typeof node.value === "string") {
+      htmlNodes.push(node);
     }
+  });
 
-    const blockAttachments = parseAttachmentBlockHtml(node.value);
-    if (!blockAttachments) {
-      return;
+  const consumed = new Set();
+
+  for (let i = 0; i < htmlNodes.length; i++) {
+    if (consumed.has(i)) continue;
+    const node = htmlNodes[i];
+
+    // Fast path: the node contains a complete attachment block.
+    let blockAttachments = parseAttachmentBlockHtml(node.value);
+    if (blockAttachments) {
+      consumed.add(i);
+      attachments.push(...blockAttachments);
+      const startOffset = getStartOffset(node);
+      const endOffset = getEndOffset(node);
+      if (typeof startOffset === "number" && typeof endOffset === "number") {
+        removalPatches.push({
+          start: startOffset,
+          end: endOffset,
+          replacement: "",
+        });
+      }
+      continue;
     }
 
-    attachments.push(...blockAttachments);
-    const startOffset = getStartOffset(node);
-    const endOffset = getEndOffset(node);
-    if (typeof startOffset !== "number" || typeof endOffset !== "number") {
-      return;
+    // Slow path: the node looks like the opener of an attachment block but
+    // is incomplete (e.g. blank lines inside caused the parser to split it).
+    // Try merging with subsequent HTML siblings until we get a valid block.
+    if (!looksLikeAttachmentBlockOpener(node.value)) continue;
+
+    let merged = node.value;
+    let lastMergedIdx = i;
+    for (let j = i + 1; j < htmlNodes.length; j++) {
+      if (consumed.has(j)) break;
+      merged += "\n" + htmlNodes[j].value;
+      blockAttachments = parseAttachmentBlockHtml(merged);
+      if (blockAttachments) {
+        lastMergedIdx = j;
+        break;
+      }
+      // Stop looking if we've gone too far (safety valve).
+      if (j - i > 5) break;
     }
 
-    removalPatches.push({
-      start: startOffset,
-      end: endOffset,
-      replacement: "",
-    });
-  });
+    if (blockAttachments) {
+      for (let k = i; k <= lastMergedIdx; k++) consumed.add(k);
+      attachments.push(...blockAttachments);
+      const startOffset = getStartOffset(htmlNodes[i]);
+      const endOffset = getEndOffset(htmlNodes[lastMergedIdx]);
+      if (typeof startOffset === "number" && typeof endOffset === "number") {
+        removalPatches.push({
+          start: startOffset,
+          end: endOffset,
+          replacement: "",
+        });
+      }
+    }
+  }
 
   const strippedMarkdown = applyPatches(markdown, removalPatches)
     .replace(/\n{3,}/g, "\n\n")