@bobbykim/manguito-cms-cli 0.11.4 → 0.12.0

package/dist/{chunk-44VXH5BN.js → chunk-EVB2E4A5.js}

@@ -9270,7 +9270,7 @@ var require_bcryptjs = __commonJS({
   }
 });
 
-// ../api/dist/chunk-IFE2L4VM.mjs
+// ../api/dist/chunk-EFTMAG7N.mjs
 init_esm_shims();
 import crypto from "crypto";
 
@@ -26681,7 +26681,7 @@ function describeSchemaChange(input) {
   return { from: from?.version ?? null, to: to.version, types, identical };
 }
 
-// ../api/dist/chunk-IFE2L4VM.mjs
+// ../api/dist/chunk-EFTMAG7N.mjs
 function isColumnBacked2(field) {
   const col = field.db_column;
   if (col === null) return false;
@@ -27063,7 +27063,7 @@ async function persistJunctionField(db, itemId, junction, relatedIds) {
     sql`, `
   );
   await db.execute(
-    junction.order_column ? sql`INSERT INTO ${tbl} (${left}, ${right}, "order") VALUES ${rows}` : sql`INSERT INTO ${tbl} (${left}, ${right}) VALUES ${rows}`
+    junction.order_column ? sql`INSERT INTO ${tbl} (${left}, ${right}, "order") VALUES ${rows} ON CONFLICT DO NOTHING` : sql`INSERT INTO ${tbl} (${left}, ${right}) VALUES ${rows} ON CONFLICT DO NOTHING`
   );
 }
 function junctionOrderBy(junction) {

package/dist/{handler-N5IMQJBP-USVWSLZP.js → handler-5OTVPIAF-JVSJWO2S.js}

@@ -12,7 +12,7 @@ import {
   isColumnBacked,
   relationCardinality,
   resolveRelationField
-} from "./chunk-44VXH5BN.js";
+} from "./chunk-EVB2E4A5.js";
 
 // ../../node_modules/.pnpm/@whatwg-node+fetch@0.10.13/node_modules/@whatwg-node/fetch/dist/shouldSkipPonyfill.js
 var require_shouldSkipPonyfill = __commonJS({
@@ -10787,10 +10787,10 @@ var require_parser = __commonJS({
   }
 });
 
-// ../api/dist/handler-N5IMQJBP.mjs
+// ../api/dist/handler-5OTVPIAF.mjs
 init_esm_shims();
 
-// ../api/dist/chunk-IMDC3NGM.mjs
+// ../api/dist/chunk-DHOVO42E.mjs
 init_esm_shims();
 
 // ../../node_modules/.pnpm/graphql-yoga@5.21.2_graphql@16.14.2/node_modules/graphql-yoga/esm/index.js
@@ -30123,7 +30123,7 @@ function createYoga(options) {
   });
 }
 
-// ../api/dist/chunk-IMDC3NGM.mjs
+// ../api/dist/chunk-DHOVO42E.mjs
 var import_dataloader = __toESM(require_dataloader(), 1);
 
 // ../../node_modules/.pnpm/@escape.tech+graphql-armor@3.2.0_@envelop+core@5.5.1_@escape.tech+graphql-armor-types@0.7.0/node_modules/@escape.tech/graphql-armor/dist/graphql-armor.esm.js
@@ -30881,7 +30881,7 @@ var EnvelopArmor = class {
   }
 };
 
-// ../api/dist/chunk-IMDC3NGM.mjs
+// ../api/dist/chunk-DHOVO42E.mjs
 var DateTimeScalar = new GraphQLScalarType({
   name: "DateTime",
   description: "ISO-8601 date-time string",

package/dist/index.js

@@ -63,7 +63,7 @@ import {
   validateCrossReferences,
   verifyPassword,
   walkSchemaDirectory
-} from "./chunk-44VXH5BN.js";
+} from "./chunk-EVB2E4A5.js";
 
 // ../../node_modules/.pnpm/postgres-array@2.0.0/node_modules/postgres-array/index.js
 var require_postgres_array = __commonJS({
@@ -5272,9 +5272,10 @@ import { Command } from "commander";
 
 // src/commands/build.ts
 init_esm_shims();
-import { mkdirSync, statSync, existsSync as existsSync3, readdirSync, writeFileSync } from "fs";
+import { mkdirSync, statSync, existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { resolve as resolve3, join as join7, dirname } from "path";
 import { createRequire } from "module";
+import { fileURLToPath } from "url";
 import { build as viteBuild } from "vite";
 import { build as tsupBuild } from "tsup";
 
@@ -16721,6 +16722,7 @@ function drizzle2(...params) {
 })(drizzle2 || (drizzle2 = {}));
 
 // ../db/dist/index.mjs
+import { createHash } from "crypto";
 import { execSync, spawnSync } from "child_process";
 import crypto2 from "crypto";
 import path from "path";
@@ -16809,6 +16811,256 @@ function createPostgresAdapter(options = {}) {
     }
   };
 }
+var MAX_IDENTIFIER = 63;
+var SUFFIX = "_unique";
+function linkUniqueName(tableName) {
+  const plain = `${tableName}${SUFFIX}`;
+  if (plain.length <= MAX_IDENTIFIER) return plain;
+  const hash = createHash("sha256").update(tableName).digest("hex").slice(0, 8);
+  return `${tableName.slice(0, 47)}_${hash}${SUFFIX}`;
+}
+function linkDedupeSql(table, left, right, hasOrder) {
+  const order = hasOrder ? '(a."order", a.ctid) > (b."order", b.ctid)' : "a.ctid > b.ctid";
+  return `DELETE FROM "${table}" a USING "${table}" b WHERE a."${left}" = b."${left}" AND a."${right}" = b."${right}" AND ${order}`;
+}
+var ADD_LINK_UNIQUE = /ALTER TABLE "([^"]+)" ADD CONSTRAINT "([^"]+)" UNIQUE\("left_id","right_id"\);/g;
+function addLinkDedupe(sql6) {
+  return sql6.replace(
+    ADD_LINK_UNIQUE,
+    (statement, table, name) => [
+      "-- Removes only repeated (left, right) pairs, keeping the lowest order, before adding the constraint.",
+      "DO $$ BEGIN",
+      `IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conrelid = '"${table}"'::regclass AND conname = '${name}') THEN`,
+      `LOCK TABLE "${table}" IN SHARE ROW EXCLUSIVE MODE;`,
+      `${linkDedupeSql(table, "left_id", "right_id", true)};`,
+      statement,
+      "END IF;",
+      "END $$;"
+    ].join("\n")
+  );
+}
+async function ensureLinkConstraints(db, registry) {
+  const owners = [
+    ...Object.values(registry.content_types),
+    ...Object.values(registry.taxonomy_types)
+  ];
+  const added = [];
+  for (const owner of owners) {
+    for (const jt of owner.db.junction_tables) {
+      const table = jt.table_name;
+      const name = linkUniqueName(table);
+      const exists2 = await db.execute(
+        sql`SELECT to_regclass(${`"${table}"`}) IS NOT NULL AS found`
+      );
+      if (!exists2.rows[0].found) continue;
+      const constrained = await db.execute(
+        sql`SELECT 1 FROM pg_constraint WHERE conrelid = ${`"${table}"`}::regclass AND conname = ${name}`
+      );
+      if (constrained.rows.length > 0) continue;
+      const orderColumn = await db.execute(
+        sql`SELECT 1 FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ${table} AND column_name = 'order'`
+      );
+      const deleted = await db.execute(
+        sql.raw(
+          `${linkDedupeSql(table, jt.left_column, jt.right_column, orderColumn.rows.length > 0)} RETURNING 1`
+        )
+      );
+      await db.execute(
+        sql.raw(
+          `ALTER TABLE "${table}" ADD CONSTRAINT "${name}" UNIQUE("${jt.left_column}", "${jt.right_column}")`
+        )
+      );
+      added.push({ table, removed: deleted.rows.length });
+    }
+  }
+  return added;
+}
+var LIMIT = 63;
+var stored = (name) => name.slice(0, LIMIT);
+var SYSTEM_TABLES = ["media", "base_paths", "roles", "users"];
+var SYSTEM_UNIQUES = [
+  { name: "base_paths_name_unique", table: "base_paths" },
+  { name: "base_paths_path_unique", table: "base_paths" },
+  { name: "roles_name_unique", table: "roles" },
+  { name: "roles_hierarchy_level_unique", table: "roles" },
+  { name: "users_email_unique", table: "users" }
+];
+function foreignKeyName(table, column, targetTable, targetColumn) {
+  return `${table}_${column}_${targetTable}_${targetColumn}_fk`;
+}
+function checkConstraintName(column) {
+  return `${column}_check`;
+}
+function primaryKeyName(table) {
+  const name = `${table}_pkey`;
+  return name.length <= LIMIT ? name : `${table.slice(0, LIMIT - "_pkey".length)}_pkey`;
+}
+function rawFieldPath(owner, field) {
+  if (owner.schema_type !== "content-type") return `fields[${field.order}].name`;
+  const t = owner.ui.tabs.findIndex((tab) => tab.fields.includes(field.name));
+  const i = t < 0 ? -1 : owner.ui.tabs[t].fields.indexOf(field.name);
+  return t < 0 ? `fields[${field.order}].name` : `fields[${t}].tab.fields[${i}].name`;
+}
+function declaredColumn(field) {
+  const column = field.db_column?.column_name;
+  return column !== void 0 && column !== field.name ? column : void 0;
+}
+function describeField(field) {
+  const column = declaredColumn(field);
+  return column !== void 0 ? `field "${field.name}" (column "${column}")` : `field "${field.name}"`;
+}
+function renameOf(field) {
+  const column = declaredColumn(field);
+  return column !== void 0 ? `change the column "${column}" of field "${field.name}"` : `rename field "${field.name}"`;
+}
+function shortenOf(field, room) {
+  const column = declaredColumn(field);
+  return column !== void 0 ? `shorten the column "${column}" of field "${field.name}" to at most ${room} characters` : `shorten field "${field.name}" to at most ${room} characters`;
+}
+var commonPrefixLength = (a2, b2) => {
+  let i = 0;
+  while (i < a2.length && i < b2.length && a2[i] === b2[i]) i++;
+  return i;
+};
+function typeTableConstraints(owner) {
+  const table = owner.db.table_name;
+  const names = [];
+  for (const field of owner.fields) {
+    const col = field.db_column;
+    if (field.field_type === "paragraph" || col === null || col.junction) continue;
+    if (col.foreign_key) {
+      const fk = col.foreign_key;
+      names.push({ name: foreignKeyName(table, col.column_name, fk.table, fk.column), kind: "foreign key", field });
+    }
+    if ((col.check_constraint?.length ?? 0) > 0) {
+      names.push({ name: checkConstraintName(col.column_name), kind: "check", field });
+    }
+  }
+  return names;
+}
+function typeTableMessage(owner, a2, b2) {
+  const table = owner.db.table_name;
+  const clash = `Postgres keeps only the first ${LIMIT} characters of a name, which are the same, so the migration would fail with "constraint already exists".`;
+  if (a2.kind === "foreign key" && b2.kind === "foreign key") {
+    const room2 = LIMIT - 1 - table.length;
+    const shared = commonPrefixLength(a2.name.slice(table.length), b2.name.slice(table.length));
+    const maxType = LIMIT - 1 - shared + (owner.name.length - table.length);
+    const fix = room2 < 1 ? `shorten the name of type "${owner.name}" to at most ${maxType} characters: its table name "${table}" leaves no room for a column in the first ${LIMIT} characters` : `${renameOf(a2.field)} or ${renameOf(b2.field)} so that the two differ within their first ${room2} characters, or shorten the name of type "${owner.name}"`;
+    return `The ${describeField(a2.field)} and the ${describeField(b2.field)} of "${owner.name}" get foreign keys "${a2.name}" and "${b2.name}". ${clash} To fix it, ${fix}.`;
+  }
+  if (a2.kind === "check" && b2.kind === "check") {
+    const room2 = LIMIT - "_check".length;
+    return `The ${describeField(a2.field)} and the ${describeField(b2.field)} of "${owner.name}" get check constraints "${a2.name}" and "${b2.name}". ${clash} To fix it, ${renameOf(a2.field)} or ${renameOf(b2.field)} so that the two differ within their first ${room2} characters.`;
+  }
+  const check = a2.kind === "check" ? a2 : b2;
+  const room = LIMIT - 1 - "_check".length;
+  return `The ${a2.kind} "${a2.name}" of the ${describeField(a2.field)} and the ${b2.kind} "${b2.name}" of the ${describeField(b2.field)}, both on "${owner.name}", are the same in their first ${LIMIT} characters. ${clash} To fix it, ${shortenOf(check.field, room)}.`;
+}
+function checkTypeTable(owner) {
+  const errors = [];
+  const first = /* @__PURE__ */ new Map();
+  for (const constraint of typeTableConstraints(owner)) {
+    const earlier = first.get(stored(constraint.name));
+    if (!earlier) {
+      first.set(stored(constraint.name), constraint);
+      continue;
+    }
+    errors.push({
+      file: owner.source_file,
+      code: "CONSTRAINT_NAME_COLLISION",
+      message: typeTableMessage(owner, earlier, constraint),
+      path: rawFieldPath(owner, constraint.field)
+    });
+  }
+  return errors;
+}
+function checkLinkTable(link, left, right, rightTable) {
+  const { owner, field, table } = link;
+  const leftFk = foreignKeyName(table, left, owner.db.table_name, "id");
+  const rightFk = foreignKeyName(table, right, rightTable, "id");
+  const names = [leftFk, rightFk, link.unique];
+  const collides = names.some((n, i) => names.some((m2, j) => i < j && stored(n) === stored(m2)));
+  if (!collides) return null;
+  const base = { file: owner.source_file, code: "CONSTRAINT_NAME_COLLISION", path: rawFieldPath(owner, field) };
+  const truncated = `Postgres keeps only the first ${LIMIT} characters of a name`;
+  if (stored(leftFk) === stored(rightFk)) {
+    const prefix = `junction_${owner.db.table_name}_`.length;
+    const room = LIMIT - 2 - prefix;
+    const fix = room < 1 ? `shorten the name of type "${owner.name}": its link table names already have ${prefix} characters before the field name` : `shorten field "${field.name}" to at most ${room} characters, or the name of type "${owner.name}"`;
+    return {
+      ...base,
+      message: `The link table of field "${field.name}" of "${owner.name}", "${table}", has ${table.length} characters, so its foreign keys "${leftFk}" and "${rightFk}" are the same in their first ${LIMIT} characters. ${truncated}, so the migration would fail with "constraint already exists". To keep the link table within ${LIMIT - 2} characters, ${fix}.`
+    };
+  }
+  return {
+    ...base,
+    message: `The link table of field "${field.name}" of "${owner.name}", "${table}", gets constraints ${names.map((n) => `"${n}"`).join(", ")}, two of which are the same in their first ${LIMIT} characters. ${truncated}, so the migration would fail with "constraint already exists". To fix it, rename field "${field.name}" of type "${owner.name}".`
+  };
+}
+function takenNames(registry, links) {
+  const taken = [];
+  for (const table of SYSTEM_TABLES) {
+    taken.push({ name: table, what: `system table "${table}"` });
+    taken.push({ name: primaryKeyName(table), what: `the primary key of system table "${table}"` });
+  }
+  for (const u of SYSTEM_UNIQUES) taken.push({ name: u.name, what: `a unique constraint of system table "${u.table}"` });
+  const types3 = [
+    ...Object.values(registry.taxonomy_types),
+    ...Object.values(registry.paragraph_types),
+    ...Object.values(registry.content_types)
+  ];
+  for (const t of types3) {
+    taken.push({ name: t.db.table_name, what: `the table of type "${t.name}"` });
+    taken.push({ name: primaryKeyName(t.db.table_name), what: `the primary key of type "${t.name}"` });
+  }
+  for (const l of links) taken.push({ name: l.table, what: `the link table of field "${l.field.name}" of "${l.owner.name}"` });
+  return taken;
+}
+function checkLinkUniques(registry, links) {
+  const first = /* @__PURE__ */ new Map();
+  for (const t of takenNames(registry, links)) {
+    if (!first.has(stored(t.name))) first.set(stored(t.name), t);
+  }
+  const errors = [];
+  for (const link of links) {
+    const key = stored(link.unique);
+    const earlier = first.get(key);
+    if (!earlier) {
+      first.set(key, { name: link.unique, what: `the unique constraint of the link table of field "${link.field.name}" of "${link.owner.name}"` });
+      continue;
+    }
+    const same = earlier.name === link.unique ? `which is also the name of ${earlier.what}` : `which is the same as ${earlier.what}, "${earlier.name}", in its first ${LIMIT} characters. Postgres keeps only the first ${LIMIT} characters of a name`;
+    errors.push({
+      file: link.owner.source_file,
+      code: "CONSTRAINT_NAME_COLLISION",
+      message: `The link table of field "${link.field.name}" of "${link.owner.name}" gets unique constraint "${link.unique}", ${same}. A unique constraint shares its name with its index, and indexes share one namespace with tables, so the migration would fail with "relation already exists". Rename field "${link.field.name}" of type "${link.owner.name}".`,
+      path: rawFieldPath(link.owner, link.field)
+    });
+  }
+  return errors;
+}
+function findConstraintNameCollisions(registry) {
+  const errors = [];
+  const typeTables = [
+    ...Object.values(registry.taxonomy_types),
+    ...Object.values(registry.paragraph_types),
+    ...Object.values(registry.content_types)
+  ];
+  for (const owner of typeTables) errors.push(...checkTypeTable(owner));
+  const links = [];
+  for (const owner of [...Object.values(registry.content_types), ...Object.values(registry.taxonomy_types)]) {
+    for (const jt of owner.db.junction_tables) {
+      const field = owner.fields.find((f) => f.db_column?.junction?.table_name === jt.table_name);
+      if (!field) continue;
+      const link = { owner, field, table: jt.table_name, unique: linkUniqueName(jt.table_name) };
+      links.push(link);
+      const error = checkLinkTable(link, jt.left_column, jt.right_column, jt.right_table);
+      if (error) errors.push(error);
+    }
+  }
+  errors.push(...checkLinkUniques(registry, links));
+  return errors;
+}
 function generateFileHeader() {
   return "import * as s from 'drizzle-orm/pg-core'\nimport { sql } from 'drizzle-orm'";
 }
@@ -16943,7 +17195,7 @@ ${colBlock2}
   const constraints = enumFields.map((f) => {
     const col = f.db_column;
     const values = col.check_constraint.map((v2) => `'${v2}'`).join(", ");
-    const cname = `${col.column_name}_check`;
+    const cname = checkConstraintName(col.column_name);
     return [
       `    ${cname}: s.check(`,
       `      '${cname}',`,
@@ -17005,7 +17257,10 @@ function generateJunctionTables(registry) {
         `      .notNull()`,
         `      .references(() => ${rightVar}.id, { onDelete: 'cascade' }),`,
         ...orderLine ? [orderLine] : [],
-        `  }`,
+        `  },`,
+        `  (table) => ({`,
+        `    pair: s.unique('${linkUniqueName(jt.table_name)}').on(table.${jt.left_column}, table.${jt.right_column}),`,
+        `  })`,
         `)`
       ].join("\n");
       tables.push(def);
@@ -17244,7 +17499,14 @@ async function runGenerate(configPath, outFolder, cwd) {
   } catch {
   }
   const beforeSet = new Set(beforeFiles);
-  return afterFiles.filter((f) => !beforeSet.has(f));
+  const added = afterFiles.filter((f) => !beforeSet.has(f));
+  for (const name of added) {
+    const file = path.join(outFolder, name);
+    const text2 = await fs.readFile(file, "utf8");
+    const rewritten = addLinkDedupe(text2);
+    if (rewritten !== text2) await fs.writeFile(file, rewritten);
+  }
+  return added;
 }
 async function generateMigration(configPath, migrationsFolder) {
   return runGenerate(configPath, migrationsFolder, path.dirname(configPath));
@@ -18678,6 +18940,14 @@ function resolveSchemaConfig(cwd, config2) {
   };
 }
 
+// src/utils/schema-checks.ts
+init_esm_shims();
+function checkRegistry(registry, maxFileSize) {
+  const crossRefErrors = validateCrossReferences(registry, maxFileSize);
+  if (crossRefErrors.length > 0) return crossRefErrors;
+  return findConstraintNameCollisions(registry);
+}
+
 // src/utils/env.ts
 init_esm_shims();
 import { existsSync as existsSync2 } from "fs";
@@ -18765,7 +19035,7 @@ async function runBuild(options, deps) {
     parsedRoles
   );
   printSchemaDeprecations(findSchemaDeprecations(registry));
-  const crossRefErrors = validateCrossReferences(registry, config2.api.media?.max_file_size);
+  const crossRefErrors = checkRegistry(registry, config2.api.media?.max_file_size);
   if (crossRefErrors.length > 0) {
     printValidationErrors(crossRefErrors, "Schema reference errors", "manguito build");
     process.exit(1);
@@ -18799,6 +19069,11 @@ async function runBuild(options, deps) {
     { adminPrefix: config2.admin.prefix, apiPrefix: config2.api.prefix },
     generatedDir
   );
+  writeFileSync(
+    join7(generatedDir, VERSIONS_RECORD),
+    JSON.stringify(installedManguitoVersions(cwd), null, 2) + "\n",
+    "utf8"
+  );
   printSuccess("Codegen complete");
   try {
     await viteBuild({
@@ -18847,11 +19122,76 @@ async function runBuild(options, deps) {
   printSuccess("Server compiled");
   process.stdout.write("\nBuild complete \u2192 dist/\n");
 }
-async function needsRebuild(cwd) {
+var VERSIONS_RECORD = "manguito-versions.json";
+var MANGUITO_PACKAGES = [
+  "@bobbykim/manguito-cms-core",
+  "@bobbykim/manguito-cms-db",
+  "@bobbykim/manguito-cms-api",
+  "@bobbykim/manguito-cms-admin",
+  "@bobbykim/manguito-cms-cli"
+];
+function installedManguitoVersions(cwd) {
+  const cwdRequire = createRequire(join7(cwd, "package.json"));
+  const versions = {};
+  for (const name of MANGUITO_PACKAGES) {
+    try {
+      let dir = dirname(cwdRequire.resolve(name));
+      for (; ; ) {
+        const pkgPath = join7(dir, "package.json");
+        if (existsSync3(pkgPath)) {
+          const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+          if (pkg.name === name && typeof pkg.version === "string") versions[name] = pkg.version;
+          break;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+    } catch {
+    }
+  }
+  const running = runningCliVersion();
+  if (running !== void 0) versions[RUNNING_CLI_KEY] = running;
+  return versions;
+}
+var RUNNING_CLI_KEY = "running-cli";
+var CLI_PACKAGE = "@bobbykim/manguito-cms-cli";
+function runningCliVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (; ; ) {
+      const pkgPath = join7(dir, "package.json");
+      if (existsSync3(pkgPath)) {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+        if (pkg.name === CLI_PACKAGE && typeof pkg.version === "string") return pkg.version;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) return void 0;
+      dir = parent;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function recordedVersions(cwd) {
+  try {
+    return JSON.parse(readFileSync2(resolve3(cwd, "dist/generated", VERSIONS_RECORD), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function sameVersions(a2, b2) {
+  const keys = Object.keys(a2);
+  return keys.length === Object.keys(b2).length && keys.every((k) => a2[k] === b2[k]);
+}
+async function needsRebuild(cwd, options = {}) {
+  const installed = options.installed ?? installedManguitoVersions(cwd);
   const sentinel = resolve3(cwd, "dist/generated/schema.ts");
   if (!existsSync3(sentinel)) return true;
+  const recorded = recordedVersions(cwd);
+  if (recorded === null || !sameVersions(recorded, installed)) return true;
   const sentinelMtime = statSync(sentinel).mtimeMs;
-  const schemasDir = resolve3(cwd, "schemas");
+  const schemasDir = options.schemaDir ?? resolve3(cwd, "schemas");
   if (!existsSync3(schemasDir)) return false;
   return walkFiles(schemasDir).some(
     (file) => statSync(file).mtimeMs > sentinelMtime
@@ -23044,9 +23384,9 @@ async function loadRelationsForEdit(db, registry, fields, id, row) {
   for (const entry of loaded) if (entry) row[entry[0]] = entry[1];
 }
 async function valuesForPublishCheck(db, registry, requiredFields, id, storedLabels, body) {
-  const stored = { ...storedLabels };
-  if (db) await loadRelationsForEdit(db, registry, requiredFields.filter((f) => !Object.hasOwn(body, f.name)), id, stored);
-  return { ...stored, ...body };
+  const stored2 = { ...storedLabels };
+  if (db) await loadRelationsForEdit(db, registry, requiredFields.filter((f) => !Object.hasOwn(body, f.name)), id, stored2);
+  return { ...stored2, ...body };
 }
 async function persistRelationFields(db, registry, fields, body, itemId, ownerTable) {
   const deltas = [];
@@ -24687,7 +25027,7 @@ function registerUserRoutes(app, db, requirePermission, requireHierarchy) {
 }
 var API_VERSION = (() => {
   try {
-    return "0.9.3";
+    return "0.9.4";
   } catch {
     return "0.0.0";
   }
@@ -25370,7 +25710,7 @@ function createCmsApp(options) {
       handler: null,
       error: null
     }));
-    const ready = import("./handler-N5IMQJBP-USVWSLZP.js").then(({ createGraphQLHandler }) => {
+    const ready = import("./handler-5OTVPIAF-JVSJWO2S.js").then(({ createGraphQLHandler }) => {
       gqlPasses.forEach((pass, i) => {
         const mount = mounts[i];
         try {
@@ -25656,6 +25996,7 @@ async function runDev(options, deps) {
   const { registry, versionModel } = loaded.value;
   await generateDrizzleConfig(config2, manguitoDir);
   await writeFile9(join11(manguitoDir, "schema.ts"), generateSchemaFile(registry), "utf8");
+  await addLinkConstraints(db.getDb(), registry);
   await runDevMigration(drizzleConfigPath);
   printSuccess(needsSeed ? "Schema tables created" : "Schema tables up to date");
   if (needsSeed) {
@@ -25851,6 +26192,13 @@ async function onSchemaFileChange(args) {
   await generateRoutes2(registry, manguitoDir);
   await generateForms(registry, join11(manguitoDir, "forms"));
   await generateNav(registry, manguitoDir);
+  try {
+    await addLinkConstraints(db.getDb(), registry);
+  } catch (err) {
+    process.stderr.write(`\u26A0 Adding link constraints failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return;
+  }
   try {
     await runDevMigration(drizzleConfigPath);
   } catch (err) {
@@ -25875,11 +26223,17 @@ async function onSchemaFileChange(args) {
   updateFetch((req) => newAdapter.app.fetch(req));
   printSuccess("Schema updated");
 }
+async function addLinkConstraints(database, registry) {
+  const results = await ensureLinkConstraints(database, registry);
+  for (const { table, removed } of results) {
+    if (removed > 0) printSuccess(`Removed ${removed} duplicate links from ${table}`);
+  }
+}
 function loadValidatedSchema(cwd, config2) {
   const parsed = parseAllSchemas(cwd, config2);
   if (!parsed.ok) return parsed;
   const registry = parsed.value;
-  const crossRefErrors = validateCrossReferences(registry, config2.api.media?.max_file_size);
+  const crossRefErrors = checkRegistry(registry, config2.api.media?.max_file_size);
   if (crossRefErrors.length > 0) return { ok: false, errors: crossRefErrors };
   const versions = loadProjectVersionModel(resolveSchemaConfig(cwd, config2), registry);
   if (!versions.ok) return { ok: false, errors: versions.errors };
@@ -26065,7 +26419,7 @@ function buildDeps(options, cwd) {
   loadEnvFile(options.env);
   return {
     buildRunner: async () => runBuild(options.env ? { env: options.env } : {}, { cwd }),
-    needsRebuild: () => needsRebuild(cwd),
+    needsRebuild: (schemaDir) => needsRebuild(cwd, { schemaDir }),
     db: createPostgresAdapter(),
     migrationsFolder: resolve8(cwd, "./migrations"),
     configPath: resolve8(cwd, "dist/generated/drizzle.config.ts"),
@@ -26133,7 +26487,7 @@ async function runMigrate(options, deps) {
     printGuidedError("DB_URL not set or database unreachable");
     process.exit(1);
   }
-  if (await deps.needsRebuild()) {
+  if (await deps.needsRebuild(resolve8(cwd, config2.schema.base_path))) {
     try {
       await deps.buildRunner();
     } catch (err) {
@@ -26319,7 +26673,7 @@ async function runValidate(options, deps) {
   if (allErrors.length === 0 && parsedRoles !== null && parsedRoutesDef !== null) {
     const registry = buildSchemaRegistry(parsedSchemas, parsedRoutesDef, parsedRoles);
     printSchemaDeprecations(findSchemaDeprecations(registry));
-    const crossRefErrors = validateCrossReferences(registry, config2.api.media?.max_file_size);
+    const crossRefErrors = checkRegistry(registry, config2.api.media?.max_file_size);
     allErrors.push(...crossRefErrors);
     if (crossRefErrors.length === 0) {
       const versions = loadProjectVersionModel(resolveSchemaConfig(cwd, config2), registry);
@@ -26635,7 +26989,7 @@ function loadWorkingRegistry(cwd, config2, command) {
     process.exit(1);
   }
   const registry = buildSchemaRegistry(parsedSchemas, parsedRoutes, parsedRoles);
-  const crossRefErrors = validateCrossReferences(registry, config2.api.media?.max_file_size);
+  const crossRefErrors = checkRegistry(registry, config2.api.media?.max_file_size);
   if (crossRefErrors.length > 0) {
     printValidationErrors(crossRefErrors, "Schema reference errors", command);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbykim/manguito-cms-cli",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "license": "MIT",
   "author": "Bobby Kim <bobby.sihun.kim@gmail.com>",
   "homepage": "https://github.com/bobbykim89/manguito-cms",
@@ -29,10 +29,10 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "vite": "^8.1.3",
-    "@bobbykim/manguito-cms-admin": "0.6.2",
-    "@bobbykim/manguito-cms-api": "0.9.3",
-    "@bobbykim/manguito-cms-db": "0.2.1",
-    "@bobbykim/manguito-cms-core": "0.11.0"
+    "@bobbykim/manguito-cms-admin": "0.6.3",
+    "@bobbykim/manguito-cms-core": "0.11.1",
+    "@bobbykim/manguito-cms-db": "0.3.0",
+    "@bobbykim/manguito-cms-api": "0.9.4"
   },
   "devDependencies": {
     "@types/node": "^25.9.5",