@jant/core 0.7.0 → 0.7.1

package/src/services/__tests__/post-timeline.test.ts

@@ -486,6 +486,133 @@ describe("PostService - Timeline features", () => {
     });
   });
 
+  // A reply can be older than its root: a post moved into a Thread keeps its
+  // own creation time, and an export without `created` dates every post by
+  // publication. Thread order still opens on the root.
+  describe("a reply created before its root", () => {
+    async function createThreadWithOlderReplies() {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "Root",
+        featured: true,
+        publishedAt: 3000,
+      });
+      const first = await postService.create({
+        format: "note",
+        bodyMarkdown: "First reply",
+        replyToId: root.id,
+        publishedAt: 1000,
+      });
+      const second = await postService.create({
+        format: "note",
+        bodyMarkdown: "Second reply",
+        replyToId: first.id,
+        publishedAt: 2000,
+      });
+      // Backdated after the fact, the way a restore lands them, so each test
+      // reads the shape without going through the reply guard.
+      for (const [id, createdAt] of [
+        [root.id, 3000],
+        [first.id, 1000],
+        [second.id, 2000],
+      ] as const) {
+        await db.update(posts).set({ createdAt }).where(eq(posts.id, id));
+      }
+      return { root, first, second };
+    }
+
+    it("opens getThread on the root", async () => {
+      const { root, first, second } = await createThreadWithOlderReplies();
+
+      const thread = await postService.getThread(root.id);
+
+      expect(thread.map((post) => post.id)).toEqual([
+        root.id,
+        first.id,
+        second.id,
+      ]);
+    });
+
+    it("opens getPublishedThreads on the root", async () => {
+      const { root, first, second } = await createThreadWithOlderReplies();
+
+      const threads = await postService.getPublishedThreads([root.id]);
+
+      expect(threads.get(root.id)?.map((post) => post.id)).toEqual([
+        root.id,
+        first.id,
+        second.id,
+      ]);
+    });
+
+    it("puts the root at position 0 of the Featured projection", async () => {
+      const { root, second } = await createThreadWithOlderReplies();
+
+      const result = await postService.getFeaturedThreadTimelineData([root.id]);
+
+      expect(
+        result
+          .get(root.id)
+          ?.posts.map(({ post, position }) => [post.id, position]),
+      ).toEqual([
+        [root.id, 0],
+        [second.id, 2],
+      ]);
+      expect(result.get(root.id)?.featuredPostIds).toEqual([root.id]);
+    });
+
+    it("ends the Thread on the newest reply, not the root", async () => {
+      const { root, second } = await createThreadWithOlderReplies();
+
+      const published = await postService.getThreadTailIds([root.id]);
+      const withDrafts = await postService.getThreadTailIds([root.id], {
+        includeDrafts: true,
+      });
+
+      expect(published.get(root.id)).toBe(second.id);
+      expect(withDrafts.get(root.id)).toBe(second.id);
+    });
+
+    it("refuses a reply to the root once a reply exists", async () => {
+      const { root, second } = await createThreadWithOlderReplies();
+
+      await expect(
+        postService.create({
+          format: "note",
+          bodyMarkdown: "Fork",
+          replyToId: root.id,
+        }),
+      ).rejects.toThrow("This post is no longer the end of the thread.");
+
+      const next = await postService.create({
+        format: "note",
+        bodyMarkdown: "Third reply",
+        replyToId: second.id,
+      });
+      expect(next.threadId).toBe(root.id);
+    });
+
+    it("folds the replies for the timeline in Thread order", async () => {
+      const { root, first, second } = await createThreadWithOlderReplies();
+
+      const context = (
+        await postService.getThreadTimelineContext([root.id])
+      ).get(root.id);
+      const previews = await postService.getThreadPreviews([root.id]);
+
+      expect(context?.leadingReplies.map((post) => post.id)).toEqual([
+        first.id,
+        second.id,
+      ]);
+      expect(context?.latestReply.id).toBe(second.id);
+      expect(context?.totalReplyCount).toBe(2);
+      expect(previews.get(root.id)?.map((post) => post.id)).toEqual([
+        first.id,
+        second.id,
+      ]);
+    });
+  });
+
   describe("timeline assembly", () => {
     it("fetches published non-reply posts for the timeline", async () => {
       const root = await postService.create({

package/src/services/__tests__/post.test.ts

@@ -13,6 +13,7 @@ import type { Database } from "../../db/index.js";
 import { createPathService } from "../path.js";
 import type { MediaService } from "../media.js";
 import { POST_BODY_HTML_VERSION } from "../../lib/post-body-html.js";
+import { ValidationError } from "../../lib/errors.js";
 import type BetterSqlite3 from "better-sqlite3";
 
 function createMockStorage() {
@@ -90,6 +91,79 @@ describe("PostService", () => {
       expect(post.threadId).toBe(post.id);
     });
 
+    it("stores an empty list item with the paragraph the schema requires", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: JSON.stringify({
+          type: "doc",
+          content: [
+            {
+              type: "orderedList",
+              content: [
+                { type: "listItem", content: [] },
+                {
+                  type: "listItem",
+                  content: [
+                    {
+                      type: "paragraph",
+                      content: [{ type: "text", text: "Install" }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        }),
+      });
+
+      const stored = JSON.parse(post.body ?? "");
+      expect(stored.content[0].content[0]).toEqual({
+        type: "listItem",
+        content: [{ type: "paragraph" }],
+      });
+    });
+
+    it("restores the creation and edit times an import passes", async () => {
+      const published = await postService.create({
+        format: "note",
+        bodyMarkdown: "Moved from another site",
+        publishedAt: 1700000500,
+        createdAt: 1700000000,
+        updatedAt: 1700009000,
+      });
+      expect(published).toMatchObject({
+        createdAt: 1700000000,
+        updatedAt: 1700009000,
+        lastActivityAt: 1700000500,
+      });
+
+      const draft = await postService.create({
+        format: "note",
+        status: "draft",
+        bodyMarkdown: "Unfinished",
+        createdAt: 1700000000,
+        updatedAt: 1700004000,
+      });
+      expect(draft).toMatchObject({
+        createdAt: 1700000000,
+        updatedAt: 1700004000,
+        lastActivityAt: 1700004000,
+      });
+
+      const backdated = await postService.create({
+        format: "note",
+        bodyMarkdown: "Only a creation time",
+        createdAt: 1700000000,
+      });
+      expect(backdated.updatedAt).toBe(1700000000);
+    });
+
+    it("rejects a body that isn't TipTap JSON", async () => {
+      await expect(
+        postService.create({ format: "note", body: "not json" }),
+      ).rejects.toThrow(ValidationError);
+    });
+
     it("creates a link post with commentary", async () => {
       const body = JSON.stringify({
         type: "doc",

package/src/services/bootstrap.ts

@@ -13,14 +13,22 @@
  * the second act runs, against the site the request resolved — the same site
  * the route's membership check reads. On a hosted install the database holds
  * every tenant, so "the only site" is not a question with an answer there.
+ *
+ * A self-hosted install that is deployed rather than clicked through runs both
+ * acts back to back without a browser — see `setUpInstance`.
  */
 
+import { and, eq } from "drizzle-orm";
 import type { DatabaseDialect } from "../db/dialect.js";
 import type { Database } from "../db/index.js";
 import {
   sqliteSchemaBundle,
   type DatabaseSchema,
 } from "../db/schema-bundle.js";
+import { AUTH_ID_PREFIX, createTypeId } from "../lib/ids.js";
+import { hashPassword, verifyPassword } from "../lib/password.js";
+import { deriveAccountName } from "../lib/schemas.js";
+import { now } from "../lib/time.js";
 import { createNavItemService } from "./navigation.js";
 import { createSettingsService } from "./settings.js";
 import { createSiteMemberService } from "./site-member.js";
@@ -73,6 +81,38 @@ export interface CompleteSiteSetupDeps {
   updateCurrentUserName?: ((displayName: string) => Promise<void>) | null;
 }
 
+export interface SetUpInstanceData {
+  /** The owner's sign-in address, normalized the way sign-in normalizes it. */
+  email: string;
+  /** The owner's password in plain text. Only its hash is stored. */
+  password: string;
+  /** The id to create the site with. See `EnsureSingleSiteOptions.id`. */
+  siteId?: string;
+  /** The site's name. Omitted leaves the built-in fallback name in place. */
+  siteName?: string;
+  /**
+   * Language the site publishes in. Omitted means the base locale, the same
+   * as an empty answer on the screen.
+   */
+  siteLanguage?: string;
+  /** The site's time zone. Omitted means UTC, as on the screen. */
+  timeZone?: string;
+}
+
+/**
+ * What `setUpInstance` found:
+ * - `created`: nothing existed, and now the account, the site and its answers do
+ * - `resumed`: an earlier run stopped after creating the account; this one
+ *   finished the rest
+ * - `already-set-up`: setup had finished before, and nothing was changed
+ */
+export type SetUpInstanceOutcome = "created" | "resumed" | "already-set-up";
+
+export interface SetUpInstanceResult {
+  outcome: SetUpInstanceOutcome;
+  siteId: string;
+}
+
 export interface BootstrapService {
   /**
    * Stand the site up around a newly created owner account.
@@ -110,6 +150,41 @@ export interface BootstrapService {
     opts: { oldLanguage: string },
     deps?: CompleteSiteSetupDeps,
   ): Promise<void>;
+
+  /**
+   * Set a self-hosted install up without a browser: the owner account, the
+   * site around it, and the answers the second screen would have collected,
+   * ending with onboarding complete.
+   *
+   * The site half is the screens' own code. The account half differs in one
+   * way: the first screen opens the account through better-auth so the
+   * browser leaves with a session, and there is no browser here to hand one
+   * to. The rows are written directly instead, with the same password hash
+   * better-auth is configured with, and named the way the first screen names
+   * them until the site's name replaces it.
+   *
+   * Safe to run on every start. An install that finished setup is left as it
+   * is, whatever this call was given — the owner may have changed their
+   * address or password since, and a restart must not undo that. A run that
+   * stopped after creating the account resumes, but only with that account's
+   * address and password, which is what the first screen asks for too.
+   *
+   * @param data - The owner's credentials and the site's answers, already
+   *   validated
+   * @returns What was found, and the site
+   * @throws {Error} On a host-based install; when the site exists under an id
+   *   other than `siteId`; when an account for another address exists; when
+   *   the password does not match the account an earlier run left
+   * @example
+   * ```ts
+   * await bootstrap.setUpInstance({
+   *   email: "owner@example.com",
+   *   password: "correct horse battery",
+   *   siteName: "Field Notes",
+   * });
+   * ```
+   */
+  setUpInstance(data: SetUpInstanceData): Promise<SetUpInstanceResult>;
 }
 
 /**
@@ -151,11 +226,11 @@ export function createBootstrapService(
     return siteId;
   }
 
+  function settingsFor(targetSiteId: string) {
+    return createSettingsService(db, targetSiteId, databaseSchema, dialect);
+  }
+
   /**
-   * The site the account step stands up. A self-hosted install has no row
-   * until now, so this is the step that creates it — along with its domain,
-   * when one is configured.
-   *
    * A host-based install refuses before anything is written. The control
    * plane creates each hosted site already provisioned, and its owner arrives
    * through the hosted handoff, the only way anyone becomes a member of one.
@@ -163,71 +238,215 @@ export function createBootstrapService(
    * any account in a database every tenant shares take a site that had lost
    * its onboarding status.
    */
-  async function siteToProvision(): Promise<string> {
+  function assertSelfHosted(step: string): void {
     if (siteResolutionMode === "host-based") {
       throw new Error(
-        "provisionOwnerAccount runs on self-hosted installs only. A hosted site's owner arrives through the control plane's handoff.",
+        `${step} runs on self-hosted installs only. A hosted site's owner arrives through the control plane's handoff.`,
       );
     }
+  }
+
+  /**
+   * Stand the site up around its owner. A self-hosted install has no row until
+   * now, so this is the step that creates it — along with its domain, when one
+   * is configured.
+   *
+   * @returns The site's id
+   */
+  async function provisionSite(
+    step: string,
+    ownerUserId: string,
+    siteOptions: EnsureSingleSiteOptions | undefined,
+  ): Promise<string> {
+    assertSelfHosted(step);
     const { site } = await createSiteService(
       db,
       databaseSchema,
-    ).ensureSingleSite(options?.bootstrapSite);
+    ).ensureSingleSite(siteOptions);
+    const navItems = createNavItemService(db, site.id, databaseSchema);
+    const siteMembers = createSiteMemberService(db, databaseSchema);
+
+    await siteMembers.ensure(site.id, ownerUserId, "owner");
+    await navItems.materializeDefaultNavigation();
+    await settingsFor(site.id).markSiteProvisioned();
     return site.id;
   }
 
+  async function recordSiteAnswers(
+    targetSiteId: string,
+    data: CompleteSiteSetupData,
+    opts: { oldLanguage: string },
+    deps: CompleteSiteSetupDeps | undefined,
+  ): Promise<void> {
+    const settings = settingsFor(targetSiteId);
+
+    const siteName = data.siteName?.trim();
+    if (siteName) {
+      await settings.set("SITE_NAME", siteName);
+      // Before onboarding closes, deliberately: if the rename fails the site
+      // is still provisioned, and the author retries the screen they were
+      // already on rather than landing in a finished site under a stale name.
+      await deps?.updateCurrentUserName?.(siteName);
+    }
+
+    // `undefined` means the shell already has one. `null` is a browser that
+    // reported nothing, which is the same UTC default the site would fall
+    // back to anyway — written so a later reader sees a chosen value.
+    if (data.timeZone !== undefined) {
+      await settings.set("TIME_ZONE", data.timeZone ?? "UTC");
+    }
+
+    await settings.confirmFirstRunLanguage(
+      {
+        siteLanguage: data.siteLanguage ?? "",
+        browserLanguage: data.browserLanguage,
+      },
+      opts,
+    );
+  }
+
+  /**
+   * The account a browserless setup stands the site up around: a new one when
+   * the install has none, or the one an interrupted run left, claimed with its
+   * own password — the way the first screen resumes by signing in.
+   */
+  async function claimOwnerAccount(
+    email: string,
+    password: string,
+  ): Promise<{ userId: string; created: boolean }> {
+    const { account, user } = databaseSchema;
+    const [existing] = await db
+      .select({ id: user.id, passwordHash: account.password })
+      .from(user)
+      .leftJoin(
+        account,
+        and(eq(account.userId, user.id), eq(account.providerId, "credential")),
+      )
+      .where(eq(user.email, email))
+      .limit(1);
+
+    if (existing) {
+      const matches =
+        !!existing.passwordHash &&
+        (await verifyPassword({ hash: existing.passwordHash, password }));
+      if (!matches) {
+        throw new Error(
+          `An earlier setup created the account for ${email}, and the password given does not match it.`,
+        );
+      }
+      return { userId: existing.id, created: false };
+    }
+
+    const [other] = await db.select({ id: user.id }).from(user).limit(1);
+    if (other) {
+      throw new Error(
+        `This install already has an account under another address. Pass that account's address and password to finish setup.`,
+      );
+    }
+
+    const userId = createTypeId(AUTH_ID_PREFIX.user);
+    const timestamp = new Date(now() * 1000);
+    await db.insert(user).values({
+      id: userId,
+      email,
+      emailVerified: false,
+      image: null,
+      // The first screen's stand-in, replaced when the site is named.
+      name: deriveAccountName(email),
+      role: "admin",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+    await db.insert(account).values({
+      id: createTypeId(AUTH_ID_PREFIX.account),
+      accountId: userId,
+      userId,
+      providerId: "credential",
+      password: await hashPassword(password),
+      accessToken: null,
+      accessTokenExpiresAt: null,
+      idToken: null,
+      refreshToken: null,
+      refreshTokenExpiresAt: null,
+      scope: null,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+    return { userId, created: true };
+  }
+
   return {
     async provisionOwnerAccount(data) {
-      const provisionedSiteId = await siteToProvision();
-      const settings = createSettingsService(
-        db,
-        provisionedSiteId,
-        databaseSchema,
-        dialect,
+      await provisionSite(
+        "provisionOwnerAccount",
+        data.ownerUserId,
+        options?.bootstrapSite,
       );
-      const navItems = createNavItemService(
-        db,
-        provisionedSiteId,
-        databaseSchema,
-      );
-      const siteMembers = createSiteMemberService(db, databaseSchema);
-
-      await siteMembers.ensure(provisionedSiteId, data.ownerUserId, "owner");
-      await navItems.materializeDefaultNavigation();
-      await settings.markSiteProvisioned();
     },
 
     async completeSiteSetup(data, opts, deps) {
-      const settings = createSettingsService(
-        db,
+      await recordSiteAnswers(
         existingSiteId("completeSiteSetup"),
-        databaseSchema,
-        dialect,
+        data,
+        opts,
+        deps,
       );
+    },
 
-      const siteName = data.siteName?.trim();
-      if (siteName) {
-        await settings.set("SITE_NAME", siteName);
-        // Before onboarding closes, deliberately: if the rename fails the site
-        // is still provisioned, and the author retries the screen they were
-        // already on rather than landing in a finished site under a stale name.
-        await deps?.updateCurrentUserName?.(siteName);
-      }
+    async setUpInstance(data) {
+      assertSelfHosted("setUpInstance");
 
-      // `undefined` means the shell already has one. `null` is a browser that
-      // reported nothing, which is the same UTC default the site would fall
-      // back to anyway — written so a later reader sees a chosen value.
-      if (data.timeZone !== undefined) {
-        await settings.set("TIME_ZONE", data.timeZone ?? "UTC");
+      const existingSite = await createSiteService(
+        db,
+        databaseSchema,
+      ).getOnlySite();
+      if (
+        existingSite &&
+        data.siteId !== undefined &&
+        existingSite.id !== data.siteId
+      ) {
+        throw new Error(
+          `This install's site is ${existingSite.id}, not ${data.siteId}. Check that the database is the one you meant.`,
+        );
+      }
+      if (
+        existingSite &&
+        (await settingsFor(existingSite.id).isOnboardingComplete())
+      ) {
+        return { outcome: "already-set-up", siteId: existingSite.id };
       }
 
-      await settings.confirmFirstRunLanguage(
+      const owner = await claimOwnerAccount(data.email, data.password);
+      const setUpSiteId = await provisionSite("setUpInstance", owner.userId, {
+        ...options?.bootstrapSite,
+        id: data.siteId,
+      });
+      const { user } = databaseSchema;
+      await recordSiteAnswers(
+        setUpSiteId,
         {
-          siteLanguage: data.siteLanguage ?? "",
-          browserLanguage: data.browserLanguage,
+          siteName: data.siteName,
+          siteLanguage: data.siteLanguage,
+          timeZone: data.timeZone ?? null,
+        },
+        {
+          oldLanguage:
+            (await settingsFor(setUpSiteId).get("SITE_LANGUAGE")) ?? "",
+        },
+        {
+          async updateCurrentUserName(displayName) {
+            await db
+              .update(user)
+              .set({ name: displayName, updatedAt: new Date(now() * 1000) })
+              .where(eq(user.id, owner.userId));
+          },
         },
-        opts,
       );
+
+      return {
+        outcome: owner.created ? "created" : "resumed",
+        siteId: setUpSiteId,
+      };
     },
   };
 }

package/src/services/custom-url.ts

@@ -108,7 +108,7 @@ export function createCustomUrlService(
               : eq(pathRegistry.collectionId, targetId),
           ),
         )
-        .orderBy(desc(pathRegistry.createdAt))
+        .orderBy(desc(pathRegistry.createdAt), desc(pathRegistry.id))
         .limit(1);
       return result[0] ? toCustomUrl(result[0]) : null;
     },
@@ -228,7 +228,7 @@ export function createCustomUrlService(
         .where(
           and(eq(pathRegistry.siteId, siteId), ne(pathRegistry.kind, "slug")),
         )
-        .orderBy(desc(pathRegistry.createdAt))
+        .orderBy(desc(pathRegistry.createdAt), desc(pathRegistry.id))
         .$dynamic();
       if (opts?.limit !== undefined) q = q.limit(opts.limit);
       if (opts?.offset !== undefined) q = q.offset(opts.offset);

package/src/services/export-theme/layouts/_default/alias.html

@@ -1,3 +1,13 @@
+{{- /*
+  Alias page. Hugo renders one of these for every entry in a post's
+  `aliases:` front matter.
+
+  `.Permalink` is the alias target. It is empty whenever the page the alias
+  points at was not built — an empty `content=0; url=` is read by browsers as
+  "reload this page", which turns the alias into an infinite refresh loop. So
+  the redirect markup is only emitted when there is somewhere to redirect to.
+*/ -}}
+{{- if .Permalink -}}
 <!doctype html>
 <html lang="{{ .Site.LanguageCode | default "en" }}">
   <head>
@@ -9,7 +19,10 @@
     <script>
       (function () {
         var target = {{ .Permalink }};
-        var rootAliases = {{ with .Params.root_aliases }}{{ . | jsonify }}{{ else }}[]{{ end }};
+        // `safeJS` keeps this an array literal. Without it Hugo's contextual
+        // escaping emits a quoted JSON string, and the loop below compares
+        // single characters instead of paths.
+        var rootAliases = {{ with .Params.root_aliases }}{{ . | jsonify | safeJS }}{{ else }}[]{{ end }};
         try {
           var path = window.location.pathname || "";
           var normalized = "/" + path.replace(/^\/+|\/+$/g, "") + "/";
@@ -47,3 +60,16 @@
     <p>Redirecting to <a href="{{ .Permalink }}">{{ .Permalink }}</a>&hellip;</p>
   </body>
 </html>
+{{- else -}}
+<!doctype html>
+<html lang="{{ .Site.LanguageCode | default "en" }}">
+  <head>
+    <meta charset="utf-8">
+    <title>{{ .Site.Title }}</title>
+    <meta name="robots" content="noindex,nofollow">
+  </head>
+  <body>
+    <p>This page is not available.</p>
+  </body>
+</html>
+{{- end -}}