erudit 4.0.0-dev.3 → 4.0.0-dev.5

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

@@ -1,84 +1,121 @@
-import { eq, like, or } from 'drizzle-orm';
-
-export async function getContentDependencies(fullId: string): Promise<{
-    hardDependencies: ContentHardDep[];
-    autoDependencies: ContentAutoDep[];
-}> {
-    const hardDependencies: ContentHardDep[] = [];
-    const autoDependencies: ContentAutoDep[] = [];
-
-    const dbContents = await ERUDIT.db.query.contentDeps.findMany({
-        columns: { fromFullId: true, toFullId: true, hard: true, reason: true },
-        where: or(
-            eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
-            like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
-        ),
-    });
-
-    for (const dbContent of dbContents) {
-        // Skip child-only self-references
-        const isToChild = dbContent.toFullId.startsWith(`${fullId}/`);
-        const isFromChild = dbContent.fromFullId.startsWith(`${fullId}/`);
-        if (isToChild && isFromChild) {
-            continue;
-        }
-
-        const dep = await getContentAutoDep(dbContent.fromFullId);
-
-        if (dbContent.hard && fullId === dbContent.toFullId) {
-            hardDependencies.push({
-                ...dep,
-                type: 'hard',
-                reason: dbContent.reason!,
-            });
-        } else {
-            autoDependencies.push(dep);
-        }
-    }
-
-    return { hardDependencies, autoDependencies };
-}
-
-export async function getContentDependents(
-    fullId: string,
-): Promise<ContentAutoDep[]> {
-    const dependents: ContentAutoDep[] = [];
-
-    const dbContents = 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}/%`),
-        ),
-    });
-
-    for (const dbContent of dbContents) {
-        // Skip child-only self-references
-        const isFromChild = dbContent.fromFullId.startsWith(`${fullId}/`);
-        const isToChild = dbContent.toFullId.startsWith(`${fullId}/`);
-        if (isFromChild && isToChild) {
-            continue;
-        }
-
-        const dep = await getContentAutoDep(dbContent.toFullId);
-        dependents.push(dep);
-    }
-
-    return dependents;
-}
-
-export async function getContentAutoDep(
-    fullId: string,
-): Promise<ContentAutoDep> {
-    const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
-    const contentType = navNode.type;
-    const title = await ERUDIT.repository.content.title(fullId);
-    const link = await ERUDIT.repository.content.link(fullId);
-
-    return {
-        type: 'auto',
-        contentType,
-        title,
-        link,
-    };
-}
+import { eq, like, or } from 'drizzle-orm';
+
+type ContentAutoDepCache = Map<string, Promise<ContentAutoDep>>;
+
+async function buildContentAutoDep(fullId: string): Promise<ContentAutoDep> {
+  const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+  const contentType = navNode.type;
+  const [title, link] = await Promise.all([
+    ERUDIT.repository.content.title(fullId),
+    ERUDIT.repository.content.link(fullId),
+  ]);
+
+  return {
+    type: 'auto',
+    contentType,
+    title,
+    link,
+  };
+}
+
+function getContentAutoDepCached(
+  fullId: string,
+  cache: ContentAutoDepCache,
+): Promise<ContentAutoDep> {
+  const existing = cache.get(fullId);
+  if (existing) {
+    return existing;
+  }
+
+  const created = buildContentAutoDep(fullId);
+  cache.set(fullId, created);
+  return created;
+}
+
+export async function getContentDependencies(fullId: string): Promise<{
+  hardDependencies: ContentHardDep[];
+  autoDependencies: ContentAutoDep[];
+}> {
+  const hardDependencies: ContentHardDep[] = [];
+  const autoDependencies: ContentAutoDep[] = [];
+  const cache: ContentAutoDepCache = new Map();
+
+  const dbContents = await ERUDIT.db.query.contentDeps.findMany({
+    columns: { fromFullId: true, toFullId: true, hard: true, reason: true },
+    where: or(
+      eq(ERUDIT.db.schema.contentDeps.toFullId, fullId),
+      like(ERUDIT.db.schema.contentDeps.toFullId, `${fullId}/%`),
+    ),
+  });
+
+  const filtered = dbContents.filter((dbContent) => {
+    // Skip child-only self-references
+    const isToChild = dbContent.toFullId.startsWith(`${fullId}/`);
+    const isFromChild = dbContent.fromFullId.startsWith(`${fullId}/`);
+    return !(isToChild && isFromChild);
+  });
+
+  // Precompute to ensure hard deps always take precedence, regardless of DB row ordering.
+  const hardDepFromIds = new Set(
+    filtered
+      .filter((dbContent) => dbContent.hard && fullId === dbContent.toFullId)
+      .map((dbContent) => dbContent.fromFullId),
+  );
+
+  const deps = await Promise.all(
+    filtered.map((dbContent) =>
+      getContentAutoDepCached(dbContent.fromFullId, cache),
+    ),
+  );
+
+  for (const [i, dbContent] of filtered.entries()) {
+    const dep = deps[i]!;
+
+    if (dbContent.hard && fullId === dbContent.toFullId) {
+      hardDependencies.push({
+        ...dep,
+        type: 'hard',
+        reason: dbContent.reason!,
+      });
+    } else if (!hardDepFromIds.has(dbContent.fromFullId)) {
+      autoDependencies.push(dep);
+    }
+  }
+
+  return { hardDependencies, autoDependencies };
+}
+
+export async function getContentDependents(
+  fullId: string,
+): Promise<ContentAutoDep[]> {
+  const cache: ContentAutoDepCache = new Map();
+
+  const dbContents = 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}/%`),
+    ),
+  });
+
+  const filtered = dbContents.filter((dbContent) => {
+    // Skip child-only self-references
+    const isFromChild = dbContent.fromFullId.startsWith(`${fullId}/`);
+    const isToChild = dbContent.toFullId.startsWith(`${fullId}/`);
+    return !(isFromChild && isToChild);
+  });
+
+  const deps = await Promise.all(
+    filtered.map((dbContent) =>
+      getContentAutoDepCached(dbContent.toFullId, cache),
+    ),
+  );
+
+  return deps;
+}
+
+export async function getContentAutoDep(
+  fullId: string,
+): Promise<ContentAutoDep> {
+  return buildContentAutoDep(fullId);
+}

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

@@ -1,11 +1,11 @@
-import { eq } from 'drizzle-orm';
-
-export async function getContentDescription(
-    fullContentId: string,
-): Promise<string | undefined> {
-    const dbContentItem = (await ERUDIT.db.query.content.findFirst({
-        where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
-    }))!;
-
-    return dbContentItem.description || undefined;
-}
+import { eq } from 'drizzle-orm';
+
+export async function getContentDescription(
+  fullContentId: string,
+): Promise<string | undefined> {
+  const dbContentItem = (await ERUDIT.db.query.content.findFirst({
+    where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
+  }))!;
+
+  return dbContentItem.description || undefined;
+}

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

@@ -1,105 +1,105 @@
-import { and, asc, eq, or } from 'drizzle-orm';
-
-export async function getContentElementSnippets(
-    fullId: string,
-): Promise<ElementSnippet[] | undefined> {
-    const snippets: ElementSnippet[] = [];
-
-    const dbSnippets = await ERUDIT.db.query.contentSnippets.findMany({
-        columns: {
-            contentProseType: true,
-            schemaName: true,
-            elementId: true,
-            snippetData: true,
-        },
-        where: and(
-            eq(ERUDIT.db.schema.contentSnippets.contentFullId, fullId),
-            or(
-                eq(ERUDIT.db.schema.contentSnippets.quick, true),
-                eq(ERUDIT.db.schema.contentSnippets.seo, true),
-            ),
-        ),
-        orderBy: (snippets) => asc(snippets.snippetId),
-    });
-
-    const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
-
-    for (const dbSnippet of dbSnippets) {
-        const link = (() => {
-            if (dbSnippet.contentProseType === 'page') {
-                return PAGES.page(navNode.shortId, dbSnippet.elementId);
-            }
-
-            return PAGES.topic(
-                dbSnippet.contentProseType,
-                navNode.shortId,
-                dbSnippet.elementId,
-            );
-        })();
-
-        const snippetData = dbSnippet.snippetData;
-
-        const snippet: ElementSnippet = {
-            link,
-            schemaName: dbSnippet.schemaName,
-            title: snippetData.title!,
-        };
-
-        if (snippetData.quick) {
-            snippet.quick = {};
-            let quickTitle: string | undefined;
-            let quickDescription: string | undefined;
-
-            if (typeof snippetData.quick === 'string') {
-                quickTitle = snippetData.quick;
-            } else if (typeof snippetData.quick === 'object') {
-                if (snippetData.quick.title) {
-                    quickTitle = snippetData.quick.title;
-                }
-                if (snippetData.quick.description) {
-                    quickDescription = snippetData.quick.description;
-                }
-            }
-
-            if (quickTitle) {
-                snippet.quick.title = quickTitle;
-            }
-            if (quickDescription) {
-                snippet.quick.description = quickDescription;
-            }
-        }
-
-        if (snippetData.seo) {
-            snippet.seo = {};
-
-            let seoTitle: string | undefined;
-            let seoDescription: string | undefined;
-
-            if (typeof snippetData.seo === 'string') {
-                seoTitle = snippetData.seo;
-            } else if (typeof snippetData.seo === 'object') {
-                if (snippetData.seo.title) {
-                    seoTitle = snippetData.seo.title;
-                }
-                if (snippetData.seo.description) {
-                    seoDescription = snippetData.seo.description;
-                }
-            }
-
-            if (seoTitle) {
-                snippet.seo.title = seoTitle;
-            }
-            if (seoDescription) {
-                snippet.seo.description = seoDescription;
-            }
-        }
-
-        if (snippetData.description) {
-            snippet.description = snippetData.description;
-        }
-
-        snippets.push(snippet);
-    }
-
-    return snippets.length > 0 ? snippets : undefined;
-}
+import { and, asc, eq, or } from 'drizzle-orm';
+
+export async function getContentElementSnippets(
+  fullId: string,
+): Promise<ElementSnippet[] | undefined> {
+  const snippets: ElementSnippet[] = [];
+
+  const dbSnippets = await ERUDIT.db.query.contentSnippets.findMany({
+    columns: {
+      contentProseType: true,
+      schemaName: true,
+      elementId: true,
+      snippetData: true,
+    },
+    where: and(
+      eq(ERUDIT.db.schema.contentSnippets.contentFullId, fullId),
+      or(
+        eq(ERUDIT.db.schema.contentSnippets.quick, true),
+        eq(ERUDIT.db.schema.contentSnippets.seo, true),
+      ),
+    ),
+    orderBy: (snippets) => asc(snippets.snippetId),
+  });
+
+  const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+
+  for (const dbSnippet of dbSnippets) {
+    const link = (() => {
+      if (dbSnippet.contentProseType === 'page') {
+        return PAGES.page(navNode.shortId, dbSnippet.elementId);
+      }
+
+      return PAGES.topic(
+        dbSnippet.contentProseType,
+        navNode.shortId,
+        dbSnippet.elementId,
+      );
+    })();
+
+    const snippetData = dbSnippet.snippetData;
+
+    const snippet: ElementSnippet = {
+      link,
+      schemaName: dbSnippet.schemaName,
+      title: snippetData.title!,
+    };
+
+    if (snippetData.quick) {
+      snippet.quick = {};
+      let quickTitle: string | undefined;
+      let quickDescription: string | undefined;
+
+      if (typeof snippetData.quick === 'string') {
+        quickTitle = snippetData.quick;
+      } else if (typeof snippetData.quick === 'object') {
+        if (snippetData.quick.title) {
+          quickTitle = snippetData.quick.title;
+        }
+        if (snippetData.quick.description) {
+          quickDescription = snippetData.quick.description;
+        }
+      }
+
+      if (quickTitle) {
+        snippet.quick.title = quickTitle;
+      }
+      if (quickDescription) {
+        snippet.quick.description = quickDescription;
+      }
+    }
+
+    if (snippetData.seo) {
+      snippet.seo = {};
+
+      let seoTitle: string | undefined;
+      let seoDescription: string | undefined;
+
+      if (typeof snippetData.seo === 'string') {
+        seoTitle = snippetData.seo;
+      } else if (typeof snippetData.seo === 'object') {
+        if (snippetData.seo.title) {
+          seoTitle = snippetData.seo.title;
+        }
+        if (snippetData.seo.description) {
+          seoDescription = snippetData.seo.description;
+        }
+      }
+
+      if (seoTitle) {
+        snippet.seo.title = seoTitle;
+      }
+      if (seoDescription) {
+        snippet.seo.description = seoDescription;
+      }
+    }
+
+    if (snippetData.description) {
+      snippet.description = snippetData.description;
+    }
+
+    snippets.push(snippet);
+  }
+
+  return snippets.length > 0 ? snippets : undefined;
+}

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

@@ -1,50 +1,50 @@
-import { eq, like } from 'drizzle-orm';
-import type { ContentExternals } from '@erudit-js/core/content/externals';
-
-export async function getContentExternals(
-    fullId: string,
-): Promise<ContentExternals> {
-    const externals: ContentExternals = [];
-
-    const dbOwnContentItem = await ERUDIT.db.query.content.findFirst({
-        columns: { externals: true },
-        where: eq(ERUDIT.db.schema.content.fullId, fullId),
-    });
-
-    if (dbOwnContentItem?.externals) {
-        externals.push({
-            type: 'own',
-            items: dbOwnContentItem.externals,
-        });
-    }
-    const parts = fullId.split('/');
-    const dbParentContentItems = [];
-
-    for (let i = parts.length - 1; i > 0; i--) {
-        const parentId = parts.slice(0, i).join('/');
-        const dbParentContentItem = await ERUDIT.db.query.content.findFirst({
-            columns: {
-                fullId: true,
-                externals: true,
-                title: true,
-            },
-            where: eq(ERUDIT.db.schema.content.fullId, parentId),
-        });
-
-        if (dbParentContentItem) {
-            dbParentContentItems.push(dbParentContentItem);
-        }
-    }
-
-    for (const dbParentContentItem of dbParentContentItems) {
-        if (dbParentContentItem?.externals) {
-            externals.push({
-                type: 'parent',
-                title: dbParentContentItem.title,
-                items: dbParentContentItem.externals,
-            });
-        }
-    }
-
-    return externals;
-}
+import { eq, like } from 'drizzle-orm';
+import type { ContentExternals } from '@erudit-js/core/content/externals';
+
+export async function getContentExternals(
+  fullId: string,
+): Promise<ContentExternals> {
+  const externals: ContentExternals = [];
+
+  const dbOwnContentItem = await ERUDIT.db.query.content.findFirst({
+    columns: { externals: true },
+    where: eq(ERUDIT.db.schema.content.fullId, fullId),
+  });
+
+  if (dbOwnContentItem?.externals) {
+    externals.push({
+      type: 'own',
+      items: dbOwnContentItem.externals,
+    });
+  }
+  const parts = fullId.split('/');
+  const dbParentContentItems = [];
+
+  for (let i = parts.length - 1; i > 0; i--) {
+    const parentId = parts.slice(0, i).join('/');
+    const dbParentContentItem = await ERUDIT.db.query.content.findFirst({
+      columns: {
+        fullId: true,
+        externals: true,
+        title: true,
+      },
+      where: eq(ERUDIT.db.schema.content.fullId, parentId),
+    });
+
+    if (dbParentContentItem) {
+      dbParentContentItems.push(dbParentContentItem);
+    }
+  }
+
+  for (const dbParentContentItem of dbParentContentItems) {
+    if (dbParentContentItem?.externals) {
+      externals.push({
+        type: 'parent',
+        title: dbParentContentItem.title,
+        items: dbParentContentItem.externals,
+      });
+    }
+  }
+
+  return externals;
+}

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

@@ -1,33 +1,33 @@
-import { eq } from 'drizzle-orm';
-import type { ContentFlags } from '@erudit-js/core/content/flags';
-
-export async function getContentFlags(
-    fullId: string,
-): Promise<ContentFlags | undefined> {
-    const flags: ContentFlags = {};
-
-    const parts = fullId.split('/');
-    for (let i = 1; i <= parts.length; i++) {
-        const trimmedId = parts.slice(0, i).join('/');
-
-        const dbContent = await ERUDIT.db.query.content.findFirst({
-            columns: { flags: true },
-            where: eq(ERUDIT.db.schema.content.fullId, trimmedId),
-        });
-
-        const dbFlags = dbContent?.flags || {};
-
-        for (const [key, value] of Object.entries(dbFlags) as [
-            keyof ContentFlags,
-            boolean,
-        ][]) {
-            if (value === false) {
-                delete flags[key];
-            } else {
-                flags[key] = value;
-            }
-        }
-    }
-
-    return Object.keys(flags).length > 0 ? flags : undefined;
-}
+import { eq } from 'drizzle-orm';
+import type { ContentFlags } from '@erudit-js/core/content/flags';
+
+export async function getContentFlags(
+  fullId: string,
+): Promise<ContentFlags | undefined> {
+  const flags: ContentFlags = {};
+
+  const parts = fullId.split('/');
+  for (let i = 1; i <= parts.length; i++) {
+    const trimmedId = parts.slice(0, i).join('/');
+
+    const dbContent = await ERUDIT.db.query.content.findFirst({
+      columns: { flags: true },
+      where: eq(ERUDIT.db.schema.content.fullId, trimmedId),
+    });
+
+    const dbFlags = dbContent?.flags || {};
+
+    for (const [key, value] of Object.entries(dbFlags) as [
+      keyof ContentFlags,
+      boolean,
+    ][]) {
+      if (value === false) {
+        delete flags[key];
+      } else {
+        flags[key] = value;
+      }
+    }
+  }
+
+  return Object.keys(flags).length > 0 ? flags : undefined;
+}

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

@@ -1,12 +1,12 @@
-import { eq } from 'drizzle-orm';
-
-export async function getContentSeo(fullContentId: string) {
-    const dbContentItem = await ERUDIT.db.query.content.findFirst({
-        columns: {
-            seo: true,
-        },
-        where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
-    });
-
-    return dbContentItem?.seo || undefined;
-}
+import { eq } from 'drizzle-orm';
+
+export async function getContentSeo(fullContentId: string) {
+  const dbContentItem = await ERUDIT.db.query.content.findFirst({
+    columns: {
+      seo: true,
+    },
+    where: eq(ERUDIT.db.schema.content.fullId, fullContentId),
+  });
+
+  return dbContentItem?.seo || undefined;
+}