smoodly 0.0.31 → 0.0.33

package/dist/space-transfer.js

@@ -0,0 +1,174 @@
+// packages/smoodly/src/space-transfer.ts
+// The pure half of `smoodly export` / `smoodly import` (spec 2026-09-28
+// export/import): which tables travel, the order they land in, how a row
+// leaves its space and enters another, and the two checks — the export's
+// mirror of the target's foreign keys and the import's "only this
+// export's rows" test. No I/O; the CLI halves are cli/export.ts and
+// cli/import.ts.
+import { CONTENT_TABLES } from "./sql-space.js";
+/** The folder layout's own version, apart from the schema (spec §7). */
+export const FORMAT = 1;
+/** Every foreign key's target lands before the row that names it (spec §9.3). */
+export const INSERT_ORDER = [
+    "pages", "page_versions", "page_locales",
+    "entries", "entry_versions", "entry_locales",
+    "assets", "refs", "paths",
+];
+/** A row's identity inside one space: its primary key without `space_id`. */
+export const ROW_KEY = {
+    pages: ["id"],
+    page_locales: ["page_id", "locale"],
+    page_versions: ["id"],
+    entries: ["id"],
+    entry_locales: ["entry_id", "locale"],
+    entry_versions: ["id"],
+    refs: ["source_kind", "source_id", "source_field", "target_id"],
+    paths: ["locale", "path"],
+    assets: ["id"],
+};
+/** The primary key as Postgres declares it — what "on conflict do nothing" names. */
+export const CONFLICT_COLUMNS = Object.fromEntries(CONTENT_TABLES.map((t) => [t, (t === "paths" ? ["space_id", ...ROW_KEY[t]] : ROW_KEY[t]).join(",")]));
+export const rowKey = (table, row) => JSON.stringify(ROW_KEY[table].map((c) => row[c]));
+/** Sorted by key, so two exports of an unchanged space diff cleanly (spec §7). */
+export function sortRows(table, rows) {
+    return rows
+        .map((row) => [rowKey(table, row), row])
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([, row]) => row);
+}
+export const emptyTables = () => Object.fromEntries(CONTENT_TABLES.map((t) => [t, []]));
+/** A row as it leaves its space: no `space_id`; an asset's path without `<space>/`. */
+export function fromSpace(table, row, space) {
+    const { space_id: _space, ...rest } = row;
+    if (table !== "assets")
+        return rest;
+    const path = String(rest.path);
+    const prefix = `${space}/`;
+    if (!path.startsWith(prefix)) {
+        throw new Error(`smoodly: asset ${String(rest.id)} is stored at "${path}", outside its space's prefix "${prefix}".`);
+    }
+    return { ...rest, path: path.slice(prefix.length) };
+}
+/** A row as it enters a space: `space_id` set; an asset's path prefixed. */
+export function intoSpace(table, row, space) {
+    return table === "assets" ? { ...row, space_id: space, path: `${space}/${String(row.path)}` } : { ...row, space_id: space };
+}
+/** Rows whose `column` names another row of the list come after it (parents, posters); a name outside the list counts as none. */
+export function referencedFirst(rows, column) {
+    const ids = new Set(rows.map((r) => String(r.id)));
+    const placed = new Set();
+    const out = [];
+    let pending = rows;
+    while (pending.length > 0) {
+        const next = [];
+        for (const row of pending) {
+            const ref = row[column];
+            if (ref == null || !ids.has(String(ref)) || placed.has(String(ref))) {
+                out.push(row);
+                placed.add(String(row.id));
+            }
+            else
+                next.push(row);
+        }
+        if (next.length === pending.length)
+            throw new Error(`smoodly: a cycle in ${column} among ${next.length} rows.`);
+        pending = next;
+    }
+    return out;
+}
+/** The tables in insert order, their rows ordered for it (spec §9.3). */
+export function insertPlan(rows) {
+    return INSERT_ORDER.map((table) => ({
+        table,
+        rows: table === "pages" || table === "entries" ? referencedFirst(rows[table], "parent_id")
+            : table === "assets" ? referencedFirst(rows[table], "poster_id")
+                : rows[table],
+    }));
+}
+/** The export's consistency check (spec §8.3): exactly the foreign keys the target enforces, one line per broken reference. */
+export function brokenReferences(rows) {
+    const ids = (table) => new Set(rows[table].map((r) => String(r.id)));
+    const pages = ids("pages");
+    const entries = ids("entries");
+    const problems = [];
+    const check = (table, column, targets, targetTable) => {
+        for (const row of rows[table]) {
+            const ref = row[column];
+            if (ref != null && !targets.has(String(ref)))
+                problems.push(`${table} ${rowKey(table, row)}: ${column} ${String(ref)} is not in ${targetTable}`);
+        }
+    };
+    check("pages", "parent_id", pages, "pages");
+    check("page_versions", "page_id", pages, "pages");
+    check("page_locales", "page_id", pages, "pages");
+    check("page_locales", "draft_version_id", ids("page_versions"), "page_versions");
+    check("entries", "parent_id", entries, "entries");
+    check("entry_versions", "entry_id", entries, "entries");
+    check("entry_locales", "entry_id", entries, "entries");
+    check("entry_locales", "draft_version_id", ids("entry_versions"), "entry_versions");
+    check("assets", "poster_id", ids("assets"), "assets");
+    return problems;
+}
+/** The import's target check (spec §9.1): per table, how many of the target's row keys this export does not hold. All zero = empty, or an earlier run. */
+export function foreignRows(target, exported) {
+    return Object.fromEntries(CONTENT_TABLES.map((table) => {
+        const own = new Set(exported[table].map((row) => rowKey(table, row)));
+        return [table, target[table].filter((key) => !own.has(key)).length];
+    }));
+}
+export const countRows = (rows) => Object.fromEntries(CONTENT_TABLES.map((t) => [t, rows[t].length]));
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const listJoin = (items) => (items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`);
+const redirectCount = (rows) => rows.paths.filter((r) => r.redirect === true).length;
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let v = n / 1024;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(1)} ${units[i]}`;
+}
+/** "14 pages (41 versions), 32 entries (118 versions), 51 assets (38.2 MB), 9 redirects" (spec §8.5). */
+export function describeExport(rows, bytes) {
+    return [
+        `${plural(rows.pages.length, "page")} (${plural(rows.page_versions.length, "version")})`,
+        `${plural(rows.entries.length, "entry", "entries")} (${plural(rows.entry_versions.length, "version")})`,
+        `${plural(rows.assets.length, "asset")} (${formatBytes(bytes)})`,
+        plural(redirectCount(rows), "redirect"),
+    ].join(", ");
+}
+/** "14 pages, 32 entries, 51 assets and 9 redirects" (spec §9.4). */
+export function describeImport(rows) {
+    return listJoin([
+        plural(rows.pages.length, "page"),
+        plural(rows.entries.length, "entry", "entries"),
+        plural(rows.assets.length, "asset"),
+        plural(redirectCount(rows), "redirect"),
+    ]);
+}
+const NOUN = {
+    pages: ["page", "pages"],
+    page_versions: ["page version", "page versions"],
+    page_locales: ["page locale row", "page locale rows"],
+    entries: ["entry", "entries"],
+    entry_versions: ["entry version", "entry versions"],
+    entry_locales: ["entry locale row", "entry locale rows"],
+    assets: ["asset", "assets"],
+    refs: ["reference row", "reference rows"],
+    paths: ["path row", "path rows"],
+};
+/** The target check's refusal (spec §9.1), naming only the tables that hold foreign rows. */
+export function notEmptyMessage(foreign) {
+    const parts = INSERT_ORDER.filter((t) => foreign[t] > 0).map((t) => plural(foreign[t], ...NOUN[t]));
+    return `The target space holds ${listJoin(parts)} that this export does not. Import needs an empty space: a new Supabase project, or \`supabase db reset\` on a local stack.`;
+}
+/** Spec §6: the target database's version must equal the export's. */
+export function versionMismatchMessage(target, exported) {
+    return target < exported
+        ? `The target database is at schema v${target} and this export is v${exported}: update smoodly to a version that ships v${exported}, run \`npx smoodly migrate\`, then \`supabase db push\`.`
+        : `The target database is at schema v${target}, newer than this export (v${exported}): migrate the source and export again.`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {

package/dist/admin/shell/page-dialogs.d.ts

@@ -1,9 +0,0 @@
-/** A URL segment from a title: lowercase ASCII letters, digits and
- *  hyphens (the path grammar, DESIGN.md OQ 24), diacritics stripped
- *  (ä → a, é → e), everything else a hyphen, no leading, trailing or
- *  doubled hyphens. */
-export declare function slugify(title: string): string;
-/** The slug field follows the title until the editor types a slug of
- *  their own; a slug equal to what the previous title produced is still
- *  "following". */
-export declare function followsTitle(slug: string, previousTitle: string): boolean;

package/dist/admin/shell/page-dialogs.js

@@ -1,19 +0,0 @@
-// Pure helpers for the page dialogs (PageDialogs.tsx).
-/** A URL segment from a title: lowercase ASCII letters, digits and
- *  hyphens (the path grammar, DESIGN.md OQ 24), diacritics stripped
- *  (ä → a, é → e), everything else a hyphen, no leading, trailing or
- *  doubled hyphens. */
-export function slugify(title) {
-    return title
-        .normalize("NFD")
-        .replace(/[̀-ͯ]/g, "")
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-}
-/** The slug field follows the title until the editor types a slug of
- *  their own; a slug equal to what the previous title produced is still
- *  "following". */
-export function followsTitle(slug, previousTitle) {
-    return slug === "" || slug === slugify(previousTitle);
-}