erudit 4.1.0 → 4.1.1

package/app/components/main/connections/Deps.vue

@@ -5,9 +5,7 @@ defineProps<{ deps: ContentDep[] }>();
 </script>
 
 <template>
-  <ScrollPane
-    class="py-normal gap-main-half flex max-h-[min(500px,30dvh)] flex-col"
-  >
+  <ScrollPane class="py-normal gap-main-half max-h-[50dvh)] flex flex-col">
     <div v-for="dep of deps" class="gap-small flex">
       <MyIcon :name="ICONS[dep.contentType]" class="relative top-1 shrink-0" />
       <div class="flex flex-col gap-0.5">

package/app/components/main/connections/Externals.vue

@@ -8,12 +8,12 @@ const phrase = await usePhrases('externals_own', 'externals_from');
 </script>
 
 <template>
-  <ScrollPane class="max-h-[min(500px,30dvh)]">
+  <ScrollPane class="max-h-[50dvh]">
     <div v-for="group of externals">
       <div
         :class="[
-          `border-border gap-small pl-small py-small bg-bg-main relative sticky
-          top-0 z-10 flex w-full items-center border-b border-dashed`,
+          `border-border gap-small pl-small py-small sticky top-0 z-10 flex
+          w-full items-center border-b border-dashed backdrop-blur-sm`,
           group.type === 'own'
             ? 'font-semibold text-amber-600 dark:text-amber-400'
             : 'text-text-muted',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,9 +24,9 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.1.0",
-    "@erudit-js/core": "4.1.0",
-    "@erudit-js/prose": "4.1.0",
+    "@erudit-js/cli": "4.1.1",
+    "@erudit-js/core": "4.1.1",
+    "@erudit-js/prose": "4.1.1",
     "unslash": "^2.0.0",
     "@floating-ui/vue": "^1.1.10",
     "@jsprose/core": "^1.0.0",

package/server/erudit/content/repository/deps.ts

@@ -4,11 +4,11 @@ export async function getContentDependencies(fullId: string) {
   const hardDependencies: ContentHardDep[] = [];
 
   const dbHardDependencies = await ERUDIT.db.query.contentDeps.findMany({
-    columns: { fromFullId: true, hard: true, reason: true },
+    columns: { toFullId: true, hard: true, reason: true },
     where: and(
       or(
-        eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
-        like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
+        eq(ERUDIT.db.schema.contentDeps.fromFullId, fullId),
+        like(ERUDIT.db.schema.contentDeps.fromFullId, `${fullId}/%`),
       ),
       eq(ERUDIT.db.schema.contentDeps.hard, true),
     ),
@@ -16,18 +16,18 @@ export async function getContentDependencies(fullId: string) {
 
   const fullId2Reason = dbHardDependencies.reduce((map, dbDependency) => {
     if (dbDependency.reason) {
-      map.set(dbDependency.fromFullId, dbDependency.reason);
+      map.set(dbDependency.toFullId, dbDependency.reason);
     }
     return map;
   }, new Map<string, string>());
 
-  const hardFromFullIds = ERUDIT.contentNav.orderIds(
-    externalFromFullIds(dbHardDependencies),
+  const hardToFullIds = ERUDIT.contentNav.orderIds(
+    externalToFullIds(dbHardDependencies),
   );
 
-  for (const fromFullId of hardFromFullIds) {
-    const reason = fullId2Reason.get(fromFullId)!;
-    const hardDep = await createContentDep('hard', fromFullId, reason);
+  for (const toFullId of hardToFullIds) {
+    const reason = fullId2Reason.get(toFullId)!;
+    const hardDep = await createContentDep('hard', toFullId, reason);
     if (hardDep) {
       hardDependencies.push(hardDep);
     }
@@ -40,23 +40,23 @@ export async function getContentDependencies(fullId: string) {
   const autoDependencies: ContentAutoDep[] = [];
 
   const dbAutoDependencies = await ERUDIT.db.query.contentDeps.findMany({
-    columns: { fromFullId: true, hard: true },
+    columns: { toFullId: true, hard: true },
     where: and(
       or(
-        eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
-        like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
+        eq(ERUDIT.db.schema.contentDeps.fromFullId, fullId),
+        like(ERUDIT.db.schema.contentDeps.fromFullId, `${fullId}/%`),
       ),
       eq(ERUDIT.db.schema.contentDeps.hard, false),
     ),
   });
 
   // Skip auto-dependency if a hard dependency from the same source exists
-  const autoFromFullIds = ERUDIT.contentNav
-    .orderIds(externalFromFullIds(dbAutoDependencies))
-    .filter((fromFullId) => !fullId2Reason.has(fromFullId));
+  const autoToFullIds = ERUDIT.contentNav
+    .orderIds(externalToFullIds(dbAutoDependencies))
+    .filter((toFullId) => !fullId2Reason.has(toFullId));
 
-  for (const fromFullId of autoFromFullIds) {
-    const autoDep = await createContentDep('auto', fromFullId);
+  for (const toFullId of autoToFullIds) {
+    const autoDep = await createContentDep('auto', toFullId);
     if (autoDep) {
       autoDependencies.push(autoDep);
     }
@@ -72,17 +72,17 @@ export async function getContentDependencies(fullId: string) {
   //
 
   // Skip dependency if it originates from current content item or its child
-  function externalFromFullIds(dbDeps: { fromFullId: string }[]) {
+  function externalToFullIds(dbDeps: { toFullId: string }[]) {
     return dbDeps.reduce((ids, dbDep) => {
-      const fromFullId = dbDep.fromFullId;
-      const isFromSelf = fromFullId === fullId;
-      const isFromChild = fromFullId.startsWith(`${fullId}/`);
+      const toFullId = dbDep.toFullId;
+      const isToSelf = toFullId === fullId;
+      const isToChild = toFullId.startsWith(`${fullId}/`);
 
-      if (isFromSelf || isFromChild) {
+      if (isToSelf || isToChild) {
         return ids;
       }
 
-      ids.push(fromFullId);
+      ids.push(toFullId);
       return ids;
     }, [] as string[]);
   }
@@ -94,30 +94,30 @@ export async function getContentDependents(
   const dbDependents = await ERUDIT.db.query.contentDeps.findMany({
     columns: { fromFullId: true, toFullId: true },
     where: or(
-      eq(ERUDIT.db.schema.contentDeps.fromFullId, fullId),
-      like(ERUDIT.db.schema.contentDeps.fromFullId, `${fullId}/%`),
+      eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
+      like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
     ),
   });
 
-  // Skip dependent if it targets current content item or its child
-  const externalTargetFullIds = dbDependents.reduce((ids, dbDependent) => {
-    const toFullId = dbDependent.toFullId;
-    const targetsSelf = toFullId === fullId;
-    const targetsChild = toFullId.startsWith(`${fullId}/`);
+  // Skip dependent if it originates from current content item or its child
+  const externalFromFullIds = dbDependents.reduce((ids, dbDependent) => {
+    const fromFullId = dbDependent.fromFullId;
+    const isFromSelf = fromFullId === fullId;
+    const isFromChild = fromFullId.startsWith(`${fullId}/`);
 
-    if (targetsSelf || targetsChild) {
+    if (isFromSelf || isFromChild) {
       return ids;
     }
 
-    ids.push(toFullId);
+    ids.push(fromFullId);
     return ids;
   }, [] as string[]);
 
-  // Order targets according to nav structure
-  const targetFullIds = ERUDIT.contentNav.orderIds(externalTargetFullIds);
+  // Order sources according to nav structure
+  const fromFullIds = ERUDIT.contentNav.orderIds(externalFromFullIds);
 
   const dependents = await Promise.all(
-    targetFullIds.map((targetFullId) => createContentDep('auto', targetFullId)),
+    fromFullIds.map((fromFullId) => createContentDep('auto', fromFullId)),
   );
 
   return dependents.filter((dep): dep is ContentAutoDep => dep !== undefined);

package/server/erudit/content/resolve/index.ts

@@ -232,7 +232,12 @@ export async function clearOldContentData(contentIds: string[]) {
 
   await ERUDIT.db
     .delete(ERUDIT.db.schema.contentDeps)
-    .where(inArray(ERUDIT.db.schema.contentDeps.toFullId, contentIds));
+    .where(
+      or(
+        inArray(ERUDIT.db.schema.contentDeps.toFullId, contentIds),
+        inArray(ERUDIT.db.schema.contentDeps.fromFullId, contentIds),
+      ),
+    );
 
   await ERUDIT.db
     .delete(ERUDIT.db.schema.contentElementStats)

package/server/erudit/content/resolve/utils/insertContentItem.ts

@@ -78,10 +78,10 @@ async function resolveHardDependencies(
   if (contentItem.dependencies) {
     for (const dependency of contentItem.dependencies) {
       await ERUDIT.db.insert(ERUDIT.db.schema.contentDeps).values({
-        fromFullId: getGlobalContentPath(
+        fromFullId: fullId,
+        toFullId: getGlobalContentPath(
           dependency.dependency as any as GlobalContentItem,
         ),
-        toFullId: fullId,
         hard: true,
         reason: dependency.reason,
       });

package/server/erudit/content/resolve/utils/insertContentResolved.ts

@@ -103,7 +103,15 @@ function filterTargetFullIds(
     } else if (storageKey.startsWith('<link:global>')) {
       try {
         const globalContentId = storageKey.replace('<link:global>/', '');
-        targetFullIds.add(globalContentToNavNode(globalContentId).fullId);
+        const targetFullId = globalContentToNavNode(globalContentId).fullId;
+
+        if (
+          metas.some(
+            (meta) => meta.type === 'Dep' || meta.type === 'Dependency',
+          )
+        ) {
+          targetFullIds.add(targetFullId);
+        }
       } catch {
         ERUDIT.log.warn(
           brokenLinkMessage(