@jant/core 0.6.16 → 0.7.0

package/src/db/__tests__/smart-collection-placement.test.ts

@@ -0,0 +1,402 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import type Database from "better-sqlite3";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
+
+/**
+ * The three tables a smart collection can be placed in, checked by inserting
+ * real rows.
+ *
+ * Reading a CHECK constraint and believing it is not the same as running it.
+ * The last time these constraints were written by hand, a test shaped exactly
+ * like this one found three bugs in a single pass: a branch that forgot to
+ * require its own foreign key, a branch that allowed two of them at once, and a
+ * unique index whose partial predicate never matched.
+ *
+ * Each case states the row it inserts and what the schema promises about it, so
+ * a failure names the rule rather than the constraint.
+ */
+
+const SITE = DEFAULT_TEST_SITE_ID;
+const NOW = 1_700_000_000;
+
+function ids(prefix: string, n: number): string[] {
+  return Array.from(
+    { length: n },
+    (_, i) => `${prefix}_0000000000000000000000000${i}`,
+  );
+}
+
+describe("smart collection placement constraints", () => {
+  let sqlite: Database.Database;
+  let smartA: string;
+  let smartB: string;
+  let collectionA: string;
+  let postA: string;
+
+  beforeEach(() => {
+    ({ sqlite } = createTestDatabase());
+    [smartA, smartB] = ids("smc", 2) as [string, string];
+    [collectionA] = ids("col", 1) as [string];
+    [postA] = ids("pst", 1) as [string];
+
+    sqlite
+      .prepare(
+        `INSERT INTO collection (id, site_id, title, sort_order, created_at, updated_at)
+         VALUES (?, ?, 'Books', 'newest', ?, ?)`,
+      )
+      .run(collectionA, SITE, NOW, NOW);
+
+    for (const id of [smartA, smartB]) {
+      sqlite
+        .prepare(
+          `INSERT INTO smart_collection (id, site_id, title, sort, created_at, updated_at)
+           VALUES (?, ?, 'Quotes', 'newest', ?, ?)`,
+        )
+        .run(id, SITE, NOW, NOW);
+    }
+
+    sqlite
+      .prepare(
+        `INSERT INTO post (
+           id, site_id, thread_id, format, status, visibility,
+           body_html, body_text, created_at, updated_at
+         ) VALUES (?, ?, ?, 'note', 'published', 'public', '', '', ?, ?)`,
+      )
+      .run(postA, SITE, postA, NOW, NOW);
+  });
+
+  function insertPath(values: Record<string, unknown>) {
+    const row = {
+      id: `pth_${Math.random().toString(36).slice(2, 12)}`,
+      site_id: SITE,
+      path: `p-${Math.random().toString(36).slice(2, 8)}`,
+      kind: "slug",
+      post_id: null,
+      collection_id: null,
+      smart_collection_id: null,
+      redirect_to_path: null,
+      redirect_type: null,
+      archive_query: null,
+      created_at: NOW,
+      updated_at: NOW,
+      ...values,
+    };
+    const keys = Object.keys(row);
+    sqlite
+      .prepare(
+        `INSERT INTO path_registry (${keys.join(", ")})
+         VALUES (${keys.map(() => "?").join(", ")})`,
+      )
+      .run(...keys.map((key) => row[key]));
+  }
+
+  function insertDirectoryItem(values: Record<string, unknown>) {
+    const row = {
+      id: `cdi_${Math.random().toString(36).slice(2, 12)}`,
+      site_id: SITE,
+      type: "smart_collection",
+      collection_id: null,
+      smart_collection_id: null,
+      label: null,
+      url: null,
+      description: null,
+      position: `a${Math.random().toString(36).slice(2, 8)}`,
+      created_at: NOW,
+      updated_at: NOW,
+      ...values,
+    };
+    const keys = Object.keys(row);
+    sqlite
+      .prepare(
+        `INSERT INTO collection_directory_item (${keys.join(", ")})
+         VALUES (${keys.map(() => "?").join(", ")})`,
+      )
+      .run(...keys.map((key) => row[key]));
+  }
+
+  function insertNavItem(values: Record<string, unknown>) {
+    const row = {
+      id: `nav_${Math.random().toString(36).slice(2, 12)}`,
+      site_id: SITE,
+      type: "smart_collection",
+      system_key: null,
+      collection_id: null,
+      smart_collection_id: null,
+      post_id: null,
+      label: "",
+      url: "/quotes",
+      placement: "header",
+      position: `a${Math.random().toString(36).slice(2, 8)}`,
+      created_at: NOW,
+      updated_at: NOW,
+      ...values,
+    };
+    const keys = Object.keys(row);
+    sqlite
+      .prepare(
+        `INSERT INTO nav_item (${keys.join(", ")})
+         VALUES (${keys.map(() => "?").join(", ")})`,
+      )
+      .run(...keys.map((key) => row[key]));
+  }
+
+  describe("path_registry", () => {
+    it("accepts a slug pointing at a smart collection", () => {
+      expect(() =>
+        insertPath({ smart_collection_id: smartA, path: "quotes" }),
+      ).not.toThrow();
+    });
+
+    it("accepts an alias pointing at a smart collection", () => {
+      expect(() =>
+        insertPath({
+          kind: "alias",
+          smart_collection_id: smartA,
+          path: "old-quotes",
+        }),
+      ).not.toThrow();
+    });
+
+    it("refuses a slug that points at two things at once", () => {
+      expect(() =>
+        insertPath({ smart_collection_id: smartA, collection_id: collectionA }),
+      ).toThrow();
+      expect(() =>
+        insertPath({ smart_collection_id: smartA, post_id: postA }),
+      ).toThrow();
+    });
+
+    it("refuses a redirect or archive row that names a smart collection", () => {
+      expect(() =>
+        insertPath({
+          kind: "redirect",
+          smart_collection_id: smartA,
+          redirect_to_path: "quotes",
+          redirect_type: 301,
+        }),
+      ).toThrow();
+      expect(() =>
+        insertPath({
+          kind: "archive",
+          smart_collection_id: smartA,
+          archive_query: "format=quote",
+        }),
+      ).toThrow();
+    });
+
+    it("allows only one slug per smart collection", () => {
+      insertPath({ smart_collection_id: smartA, path: "quotes" });
+      expect(() =>
+        insertPath({ smart_collection_id: smartA, path: "quotes-2" }),
+      ).toThrow();
+
+      // An alias is not a second slug, so it is still allowed.
+      expect(() =>
+        insertPath({
+          kind: "alias",
+          smart_collection_id: smartA,
+          path: "old-quotes",
+        }),
+      ).not.toThrow();
+    });
+
+    it("keeps smart collections in the same address space as everything else", () => {
+      insertPath({ smart_collection_id: smartA, path: "quotes" });
+      expect(() =>
+        insertPath({ collection_id: collectionA, path: "quotes" }),
+      ).toThrow();
+      expect(() => insertPath({ post_id: postA, path: "quotes" })).toThrow();
+    });
+  });
+
+  describe("collection_directory_item", () => {
+    it("accepts a smart collection row", () => {
+      expect(() =>
+        insertDirectoryItem({ smart_collection_id: smartA }),
+      ).not.toThrow();
+    });
+
+    it("refuses a smart collection row with no target", () => {
+      expect(() => insertDirectoryItem({})).toThrow();
+    });
+
+    it("refuses a smart collection row carrying a label or url", () => {
+      expect(() =>
+        insertDirectoryItem({ smart_collection_id: smartA, label: "Quotes" }),
+      ).toThrow();
+      expect(() =>
+        insertDirectoryItem({ smart_collection_id: smartA, url: "/quotes" }),
+      ).toThrow();
+    });
+
+    it("refuses every other row type carrying a smart collection", () => {
+      expect(() =>
+        insertDirectoryItem({
+          type: "collection",
+          collection_id: collectionA,
+          smart_collection_id: smartA,
+        }),
+      ).toThrow();
+      expect(() =>
+        insertDirectoryItem({ type: "divider", smart_collection_id: smartA }),
+      ).toThrow();
+      expect(() =>
+        insertDirectoryItem({
+          type: "link",
+          label: "Elsewhere",
+          url: "https://example.com",
+          smart_collection_id: smartA,
+        }),
+      ).toThrow();
+    });
+
+    it("places a smart collection at most once", () => {
+      insertDirectoryItem({ smart_collection_id: smartA });
+      expect(() =>
+        insertDirectoryItem({ smart_collection_id: smartA }),
+      ).toThrow();
+      expect(() =>
+        insertDirectoryItem({ smart_collection_id: smartB }),
+      ).not.toThrow();
+    });
+  });
+
+  describe("nav_item", () => {
+    it("accepts a smart collection nav item", () => {
+      expect(() =>
+        insertNavItem({ smart_collection_id: smartA }),
+      ).not.toThrow();
+    });
+
+    it("refuses a smart collection nav item with no target", () => {
+      expect(() => insertNavItem({})).toThrow();
+    });
+
+    it("refuses every other nav type carrying a smart collection", () => {
+      expect(() =>
+        insertNavItem({
+          type: "link",
+          smart_collection_id: smartA,
+          label: "Elsewhere",
+        }),
+      ).toThrow();
+      expect(() =>
+        insertNavItem({
+          type: "system",
+          system_key: "latest",
+          smart_collection_id: smartA,
+        }),
+      ).toThrow();
+      expect(() =>
+        insertNavItem({
+          type: "collection",
+          collection_id: collectionA,
+          smart_collection_id: smartA,
+        }),
+      ).toThrow();
+      expect(() =>
+        insertNavItem({
+          type: "page",
+          post_id: postA,
+          smart_collection_id: smartA,
+        }),
+      ).toThrow();
+    });
+
+    it("adds a smart collection to navigation at most once", () => {
+      insertNavItem({ smart_collection_id: smartA });
+      expect(() => insertNavItem({ smart_collection_id: smartA })).toThrow();
+      expect(() =>
+        insertNavItem({ smart_collection_id: smartB }),
+      ).not.toThrow();
+    });
+  });
+
+  describe("smart_collection", () => {
+    it("refuses a private visibility condition", () => {
+      // The one value a published page can never name. Enforced in the column,
+      // not only in Zod, so no import path or backfill can slip one in.
+      expect(() =>
+        sqlite
+          .prepare(
+            `INSERT INTO smart_collection (id, site_id, title, visibility, sort, created_at, updated_at)
+             VALUES (?, ?, 'Private', 'private', 'newest', ?, ?)`,
+          )
+          .run(`smc_private0000000000000000000`, SITE, NOW, NOW),
+      ).toThrow();
+    });
+
+    it("refuses a sort or layout it cannot render", () => {
+      expect(() =>
+        sqlite
+          .prepare(
+            `INSERT INTO smart_collection (id, site_id, title, sort, created_at, updated_at)
+             VALUES (?, ?, 'Bad sort', 'rating_asc', ?, ?)`,
+          )
+          .run(`smc_badsort00000000000000000000`, SITE, NOW, NOW),
+      ).toThrow();
+      expect(() =>
+        sqlite
+          .prepare(
+            `INSERT INTO smart_collection (id, site_id, title, sort, layout, created_at, updated_at)
+             VALUES (?, ?, 'Bad layout', 'newest', 'carousel', ?, ?)`,
+          )
+          .run(`smc_badlayout00000000000000000`, SITE, NOW, NOW),
+      ).toThrow();
+    });
+
+    it("leaves a deleted collection's id in place rather than widening", () => {
+      sqlite
+        .prepare(`UPDATE smart_collection SET collection_id = ? WHERE id = ?`)
+        .run(collectionA, smartA);
+
+      // No foreign key on this column, alone in the schema. RESTRICT would fail
+      // anonymously and make every bulk delete an ordering rule; SET NULL would
+      // turn a curated page into the whole archive. The refusal an author sees
+      // is `smartCollections.assertCollectionUnused()`, and what is left if
+      // something reaches around it is a condition naming a collection that no
+      // longer exists — which matches nothing.
+      expect(() =>
+        sqlite.prepare(`DELETE FROM collection WHERE id = ?`).run(collectionA),
+      ).not.toThrow();
+
+      const row = sqlite
+        .prepare(`SELECT collection_id FROM smart_collection WHERE id = ?`)
+        .get(smartA) as { collection_id: string | null };
+      expect(row.collection_id).toBe(collectionA);
+    });
+
+    it("refuses a year no timestamp could carry", () => {
+      // `Date.UTC` returns NaN past year 275760, and a NaN bound is a
+      // comparison every row fails with nothing to report.
+      for (const year of [1970, 10000]) {
+        expect(() =>
+          sqlite
+            .prepare(
+              `INSERT INTO smart_collection (id, site_id, title, year, sort, created_at, updated_at)
+               VALUES (?, ?, 'Bad year', ?, 'newest', ?, ?)`,
+            )
+            .run(
+              `smc_year${year}000000000000000000`.slice(0, 30),
+              SITE,
+              year,
+              NOW,
+              NOW,
+            ),
+        ).toThrow();
+      }
+
+      expect(() =>
+        sqlite
+          .prepare(
+            `INSERT INTO smart_collection (id, site_id, title, year, sort, created_at, updated_at)
+             VALUES (?, ?, 'Edge years', 9999, 'newest', ?, ?)`,
+          )
+          .run(`smc_year9999000000000000000000`.slice(0, 30), SITE, NOW, NOW),
+      ).not.toThrow();
+    });
+  });
+});

package/src/db/backfills/0006_clear_mirrored_page_nav_labels.sql

@@ -0,0 +1,31 @@
+-- Clear page and collection nav labels that merely mirror their target's title.
+-- Previously these items stored a snapshot of the post or collection title taken
+-- when the item was added, so renaming the target left the nav entry behind. Now
+-- an empty label means "follow the target" and any non-empty value is a label the
+-- author typed, which wins in every language view.
+--
+-- Rows whose stored label differs from the current title were customized and are
+-- left alone. Idempotent: rerunning matches nothing once the labels are empty.
+UPDATE "nav_item"
+SET "label" = ''
+WHERE "type" = 'page'
+  AND "post_id" IS NOT NULL
+  AND "label" <> ''
+  AND "label" = (
+    SELECT trim("post"."title")
+    FROM "post"
+    WHERE "post"."id" = "nav_item"."post_id"
+      AND "post"."site_id" = "nav_item"."site_id"
+  );
+
+UPDATE "nav_item"
+SET "label" = ''
+WHERE "type" = 'collection'
+  AND "collection_id" IS NOT NULL
+  AND "label" <> ''
+  AND "label" = (
+    SELECT trim("collection"."title")
+    FROM "collection"
+    WHERE "collection"."id" = "nav_item"."collection_id"
+      AND "collection"."site_id" = "nav_item"."site_id"
+  );

package/src/db/migrations/0032_married_tomas.sql

@@ -0,0 +1,3 @@
+ALTER TABLE `post` ADD `language` text;--> statement-breakpoint
+ALTER TABLE `post` ADD `translation_group_id` text;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_post_site_translation_group_language` ON `post` (`site_id`,`translation_group_id`,`language`) WHERE "post"."translation_group_id" IS NOT NULL;

package/src/db/migrations/0033_busy_johnny_storm.sql

@@ -0,0 +1,198 @@
+CREATE TABLE `smart_collection` (
+	`id` text PRIMARY KEY NOT NULL,
+	`site_id` text NOT NULL,
+	`title` text NOT NULL,
+	`description` text,
+	`format` text,
+	`year` integer,
+	`collection_id` text,
+	`media` text,
+	`has_title` integer,
+	`has_replies` integer,
+	`visibility` text,
+	`sort` text DEFAULT 'newest' NOT NULL,
+	`layout` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`site_id`) REFERENCES `site`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "chk_smart_collection_format" CHECK("smart_collection"."format" IS NULL OR "smart_collection"."format" IN ('note', 'link', 'quote')),
+	CONSTRAINT "chk_smart_collection_visibility" CHECK("smart_collection"."visibility" IS NULL OR "smart_collection"."visibility" IN ('public', 'featured', 'latest_hidden')),
+	CONSTRAINT "chk_smart_collection_sort" CHECK("smart_collection"."sort" IN ('newest', 'oldest', 'updated', 'rating_desc')),
+	CONSTRAINT "chk_smart_collection_layout" CHECK("smart_collection"."layout" IS NULL OR "smart_collection"."layout" IN ('list', 'grid')),
+	CONSTRAINT "chk_smart_collection_year" CHECK("smart_collection"."year" IS NULL OR "smart_collection"."year" BETWEEN 1971 AND 9999)
+);
+--> statement-breakpoint
+CREATE INDEX `idx_smart_collection_site_created_at` ON `smart_collection` (`site_id`,`created_at`);--> statement-breakpoint
+CREATE INDEX `idx_smart_collection_site_collection_id` ON `smart_collection` (`site_id`,`collection_id`);--> statement-breakpoint
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE `__new_collection_directory_item` (
+	`id` text PRIMARY KEY NOT NULL,
+	`site_id` text NOT NULL,
+	`type` text NOT NULL,
+	`collection_id` text,
+	`smart_collection_id` text,
+	`label` text,
+	`url` text,
+	`description` text,
+	`position` text DEFAULT 'a0' NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`site_id`) REFERENCES `site`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`collection_id`) REFERENCES `collection`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`smart_collection_id`) REFERENCES `smart_collection`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "chk_collection_directory_item_type" CHECK("__new_collection_directory_item"."type" IN ('collection', 'smart_collection', 'divider', 'link')),
+	CONSTRAINT "chk_collection_directory_item_shape" CHECK((
+        "__new_collection_directory_item"."type" = 'collection'
+        AND "__new_collection_directory_item"."collection_id" IS NOT NULL
+        AND "__new_collection_directory_item"."smart_collection_id" IS NULL
+        AND "__new_collection_directory_item"."label" IS NULL
+        AND "__new_collection_directory_item"."url" IS NULL
+      ) OR (
+        "__new_collection_directory_item"."type" = 'smart_collection'
+        AND "__new_collection_directory_item"."collection_id" IS NULL
+        AND "__new_collection_directory_item"."smart_collection_id" IS NOT NULL
+        AND "__new_collection_directory_item"."label" IS NULL
+        AND "__new_collection_directory_item"."url" IS NULL
+      ) OR (
+        "__new_collection_directory_item"."type" = 'divider'
+        AND "__new_collection_directory_item"."collection_id" IS NULL
+        AND "__new_collection_directory_item"."smart_collection_id" IS NULL
+        AND "__new_collection_directory_item"."url" IS NULL
+      ) OR (
+        "__new_collection_directory_item"."type" = 'link'
+        AND "__new_collection_directory_item"."collection_id" IS NULL
+        AND "__new_collection_directory_item"."smart_collection_id" IS NULL
+        AND "__new_collection_directory_item"."label" IS NOT NULL
+        AND "__new_collection_directory_item"."url" IS NOT NULL
+      )),
+	CONSTRAINT "chk_collection_directory_item_label" CHECK("__new_collection_directory_item"."type" NOT IN ('collection', 'smart_collection') OR "__new_collection_directory_item"."label" IS NULL),
+	CONSTRAINT "chk_collection_directory_item_description" CHECK("__new_collection_directory_item"."type" = 'link' OR "__new_collection_directory_item"."description" IS NULL)
+);
+--> statement-breakpoint
+INSERT INTO `__new_collection_directory_item`("id", "site_id", "type", "collection_id", "smart_collection_id", "label", "url", "description", "position", "created_at", "updated_at") SELECT "id", "site_id", "type", "collection_id", NULL, "label", "url", "description", "position", "created_at", "updated_at" FROM `collection_directory_item`;--> statement-breakpoint
+DROP TABLE `collection_directory_item`;--> statement-breakpoint
+ALTER TABLE `__new_collection_directory_item` RENAME TO `collection_directory_item`;--> statement-breakpoint
+CREATE INDEX `idx_collection_directory_item_site_collection_id` ON `collection_directory_item` (`site_id`,`collection_id`);--> statement-breakpoint
+CREATE INDEX `idx_collection_directory_item_site_smart_collection_id` ON `collection_directory_item` (`site_id`,`smart_collection_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_collection_directory_item_site_position` ON `collection_directory_item` (`site_id`,`position`);--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_collection_directory_item_site_collection_once` ON `collection_directory_item` (`site_id`,`collection_id`) WHERE "collection_directory_item"."type" = 'collection' AND "collection_directory_item"."collection_id" IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_collection_directory_item_site_smart_collection_once` ON `collection_directory_item` (`site_id`,`smart_collection_id`) WHERE "collection_directory_item"."type" = 'smart_collection' AND "collection_directory_item"."smart_collection_id" IS NOT NULL;--> statement-breakpoint
+CREATE TABLE `__new_nav_item` (
+	`id` text PRIMARY KEY NOT NULL,
+	`site_id` text NOT NULL,
+	`type` text DEFAULT 'link' NOT NULL,
+	`system_key` text,
+	`collection_id` text,
+	`smart_collection_id` text,
+	`post_id` text,
+	`label` text NOT NULL,
+	`url` text NOT NULL,
+	`placement` text DEFAULT 'header' NOT NULL,
+	`position` text DEFAULT 'a0' NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`site_id`) REFERENCES `site`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`collection_id`) REFERENCES `collection`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`smart_collection_id`) REFERENCES `smart_collection`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`post_id`) REFERENCES `post`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "chk_nav_item_type" CHECK("__new_nav_item"."type" IN ('link', 'system', 'collection', 'smart_collection', 'page')),
+	CONSTRAINT "chk_nav_item_placement" CHECK("__new_nav_item"."placement" IN ('header', 'more')),
+	CONSTRAINT "chk_nav_item_shape" CHECK((
+        "__new_nav_item"."type" = 'link'
+        AND "__new_nav_item"."system_key" IS NULL
+        AND "__new_nav_item"."collection_id" IS NULL
+        AND "__new_nav_item"."smart_collection_id" IS NULL
+        AND "__new_nav_item"."post_id" IS NULL
+      ) OR (
+        "__new_nav_item"."type" = 'system'
+        AND "__new_nav_item"."system_key" IS NOT NULL
+        AND "__new_nav_item"."collection_id" IS NULL
+        AND "__new_nav_item"."smart_collection_id" IS NULL
+        AND "__new_nav_item"."post_id" IS NULL
+      ) OR (
+        "__new_nav_item"."type" = 'collection'
+        AND "__new_nav_item"."system_key" IS NULL
+        AND "__new_nav_item"."collection_id" IS NOT NULL
+        AND "__new_nav_item"."smart_collection_id" IS NULL
+        AND "__new_nav_item"."post_id" IS NULL
+      ) OR (
+        "__new_nav_item"."type" = 'smart_collection'
+        AND "__new_nav_item"."system_key" IS NULL
+        AND "__new_nav_item"."collection_id" IS NULL
+        AND "__new_nav_item"."smart_collection_id" IS NOT NULL
+        AND "__new_nav_item"."post_id" IS NULL
+      ) OR (
+        "__new_nav_item"."type" = 'page'
+        AND "__new_nav_item"."system_key" IS NULL
+        AND "__new_nav_item"."collection_id" IS NULL
+        AND "__new_nav_item"."smart_collection_id" IS NULL
+        AND "__new_nav_item"."post_id" IS NOT NULL
+      ))
+);
+--> statement-breakpoint
+INSERT INTO `__new_nav_item`("id", "site_id", "type", "system_key", "collection_id", "smart_collection_id", "post_id", "label", "url", "placement", "position", "created_at", "updated_at") SELECT "id", "site_id", "type", "system_key", "collection_id", NULL, "post_id", "label", "url", "placement", "position", "created_at", "updated_at" FROM `nav_item`;--> statement-breakpoint
+DROP TABLE `nav_item`;--> statement-breakpoint
+ALTER TABLE `__new_nav_item` RENAME TO `nav_item`;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_nav_item_site_position` ON `nav_item` (`site_id`,`position`);--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_nav_item_site_system_key` ON `nav_item` (`site_id`,`system_key`) WHERE "nav_item"."system_key" IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_nav_item_site_collection_id` ON `nav_item` (`site_id`,`collection_id`) WHERE "nav_item"."collection_id" IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_nav_item_site_smart_collection_id` ON `nav_item` (`site_id`,`smart_collection_id`) WHERE "nav_item"."smart_collection_id" IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_nav_item_site_post_id` ON `nav_item` (`site_id`,`post_id`) WHERE "nav_item"."post_id" IS NOT NULL;--> statement-breakpoint
+CREATE TABLE `__new_path_registry` (
+	`id` text PRIMARY KEY NOT NULL,
+	`site_id` text NOT NULL,
+	`path` text NOT NULL,
+	`kind` text NOT NULL,
+	`post_id` text,
+	`collection_id` text,
+	`smart_collection_id` text,
+	`redirect_to_path` text,
+	`redirect_type` integer,
+	`archive_query` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`site_id`) REFERENCES `site`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`post_id`) REFERENCES `post`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`collection_id`) REFERENCES `collection`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`smart_collection_id`) REFERENCES `smart_collection`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "chk_path_registry_kind" CHECK("__new_path_registry"."kind" IN ('slug', 'alias', 'redirect', 'archive')),
+	CONSTRAINT "chk_path_registry_shape" CHECK((
+        "__new_path_registry"."kind" IN ('slug', 'alias')
+        AND (
+          ("__new_path_registry"."post_id" IS NOT NULL AND "__new_path_registry"."collection_id" IS NULL AND "__new_path_registry"."smart_collection_id" IS NULL)
+          OR ("__new_path_registry"."post_id" IS NULL AND "__new_path_registry"."collection_id" IS NOT NULL AND "__new_path_registry"."smart_collection_id" IS NULL)
+          OR ("__new_path_registry"."post_id" IS NULL AND "__new_path_registry"."collection_id" IS NULL AND "__new_path_registry"."smart_collection_id" IS NOT NULL)
+        )
+        AND "__new_path_registry"."redirect_to_path" IS NULL
+        AND "__new_path_registry"."redirect_type" IS NULL
+        AND "__new_path_registry"."archive_query" IS NULL
+      ) OR (
+        "__new_path_registry"."kind" = 'redirect'
+        AND "__new_path_registry"."post_id" IS NULL
+        AND "__new_path_registry"."collection_id" IS NULL
+        AND "__new_path_registry"."smart_collection_id" IS NULL
+        AND "__new_path_registry"."redirect_to_path" IS NOT NULL
+        AND "__new_path_registry"."redirect_type" IN (301, 302)
+        AND "__new_path_registry"."archive_query" IS NULL
+      ) OR (
+        "__new_path_registry"."kind" = 'archive'
+        AND "__new_path_registry"."post_id" IS NULL
+        AND "__new_path_registry"."collection_id" IS NULL
+        AND "__new_path_registry"."smart_collection_id" IS NULL
+        AND "__new_path_registry"."redirect_to_path" IS NULL
+        AND "__new_path_registry"."redirect_type" IS NULL
+        AND "__new_path_registry"."archive_query" IS NOT NULL
+      ))
+);
+--> statement-breakpoint
+INSERT INTO `__new_path_registry`("id", "site_id", "path", "kind", "post_id", "collection_id", "smart_collection_id", "redirect_to_path", "redirect_type", "archive_query", "created_at", "updated_at") SELECT "id", "site_id", "path", "kind", "post_id", "collection_id", NULL, "redirect_to_path", "redirect_type", "archive_query", "created_at", "updated_at" FROM `path_registry`;--> statement-breakpoint
+DROP TABLE `path_registry`;--> statement-breakpoint
+ALTER TABLE `__new_path_registry` RENAME TO `path_registry`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_path_registry_site_path` ON `path_registry` (`site_id`,`path`);--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_path_registry_site_post_slug` ON `path_registry` (`site_id`,`post_id`) WHERE "path_registry"."kind" = 'slug' AND "path_registry"."post_id" IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_path_registry_site_collection_slug` ON `path_registry` (`site_id`,`collection_id`) WHERE "path_registry"."kind" = 'slug' AND "path_registry"."collection_id" IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_path_registry_site_smart_collection_slug` ON `path_registry` (`site_id`,`smart_collection_id`) WHERE "path_registry"."kind" = 'slug' AND "path_registry"."smart_collection_id" IS NOT NULL;--> statement-breakpoint
+CREATE INDEX `idx_path_registry_site_post_id` ON `path_registry` (`site_id`,`post_id`);--> statement-breakpoint
+CREATE INDEX `idx_path_registry_site_collection_id` ON `path_registry` (`site_id`,`collection_id`);--> statement-breakpoint
+CREATE INDEX `idx_path_registry_site_smart_collection_id` ON `path_registry` (`site_id`,`smart_collection_id`);

package/src/db/migrations/0034_cheerful_rumiko_fujikawa.sql

@@ -0,0 +1,35 @@
+-- `updated` was a fourth smart collection order until `newest` came to mean the
+-- same thing. The rebuild below narrows the CHECK to three, so any row still
+-- naming it has to be moved first or the copy fails on its own constraint.
+UPDATE `smart_collection` SET `sort` = 'newest' WHERE `sort` = 'updated';--> statement-breakpoint
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE `__new_smart_collection` (
+	`id` text PRIMARY KEY NOT NULL,
+	`site_id` text NOT NULL,
+	`title` text NOT NULL,
+	`description` text,
+	`format` text,
+	`year` integer,
+	`collection_id` text,
+	`media` text,
+	`has_title` integer,
+	`has_replies` integer,
+	`visibility` text,
+	`sort` text DEFAULT 'newest' NOT NULL,
+	`layout` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`site_id`) REFERENCES `site`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "chk_smart_collection_format" CHECK("__new_smart_collection"."format" IS NULL OR "__new_smart_collection"."format" IN ('note', 'link', 'quote')),
+	CONSTRAINT "chk_smart_collection_visibility" CHECK("__new_smart_collection"."visibility" IS NULL OR "__new_smart_collection"."visibility" IN ('public', 'featured', 'latest_hidden')),
+	CONSTRAINT "chk_smart_collection_sort" CHECK("__new_smart_collection"."sort" IN ('newest', 'oldest', 'rating_desc')),
+	CONSTRAINT "chk_smart_collection_layout" CHECK("__new_smart_collection"."layout" IS NULL OR "__new_smart_collection"."layout" IN ('list', 'grid')),
+	CONSTRAINT "chk_smart_collection_year" CHECK("__new_smart_collection"."year" IS NULL OR "__new_smart_collection"."year" BETWEEN 1971 AND 9999)
+);
+--> statement-breakpoint
+INSERT INTO `__new_smart_collection`("id", "site_id", "title", "description", "format", "year", "collection_id", "media", "has_title", "has_replies", "visibility", "sort", "layout", "created_at", "updated_at") SELECT "id", "site_id", "title", "description", "format", "year", "collection_id", "media", "has_title", "has_replies", "visibility", "sort", "layout", "created_at", "updated_at" FROM `smart_collection`;--> statement-breakpoint
+DROP TABLE `smart_collection`;--> statement-breakpoint
+ALTER TABLE `__new_smart_collection` RENAME TO `smart_collection`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;--> statement-breakpoint
+CREATE INDEX `idx_smart_collection_site_created_at` ON `smart_collection` (`site_id`,`created_at`);--> statement-breakpoint
+CREATE INDEX `idx_smart_collection_site_collection_id` ON `smart_collection` (`site_id`,`collection_id`);