erudit 4.2.0-dev.1 → 4.3.0-dev.1

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

@@ -1,10 +1,10 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import type { ContentNavNode } from '../../nav/types';
 
 export function logContentError(contentNode: ContentNavNode) {
   ERUDIT.log.error(
     `Error parsing ${contentNode.type} ${ERUDIT.log.stress(
       contentNode.fullId,
-    )}!\nLocation: ${chalk.red(ERUDIT.paths.project(`content/${contentNode.contentRelPath}`))}`,
+    )}!\nLocation: ${styleText('red', ERUDIT.paths.project(`content/${contentNode.contentRelPath}`))}`,
   );
 }

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

@@ -1,7 +1,7 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { sql } from 'drizzle-orm';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
-import { builtLinkObject } from '../../global/build';
+import { builtValidPaths } from '../../global/build';
 import type {
   ContentLinks,
   ContentLinkUsage,
@@ -80,7 +80,24 @@ async function insertContentDeps(
     await ERUDIT.db
       .insert(ERUDIT.db.schema.contentDeps)
       .values(contentDeps)
-      .onConflictDoNothing();
+      .onConflictDoUpdate({
+        target: [
+          ERUDIT.db.schema.contentDeps.fromFullId,
+          ERUDIT.db.schema.contentDeps.toFullId,
+        ],
+        set: {
+          // Merge unique names from the auto dep into the existing row
+          // (which may already be a hard dep that has no uniqueNames yet).
+          // Only uniqueNames is updated — hard/reason are left untouched.
+          uniqueNames: sql`CASE
+            WHEN ${ERUDIT.db.schema.contentDeps.uniqueNames} IS NULL
+              THEN excluded.uniqueNames
+            WHEN excluded.uniqueNames IS NULL
+              THEN ${ERUDIT.db.schema.contentDeps.uniqueNames}
+            ELSE ${ERUDIT.db.schema.contentDeps.uniqueNames} || ',' || excluded.uniqueNames
+          END`,
+        },
+      });
   }
 }
 
@@ -93,7 +110,7 @@ function filterTargetMap(
   const brokenLinkMessage = (message: string, metas: ContentLinkUsage[]) => {
     let output = `${message} in ${ERUDIT.log.stress(contentFullId)}:\n`;
     for (const { type, label } of metas) {
-      output += `  ${chalk.gray('➔')}  <${type}>${label}</${type}>\n`;
+      output += `  ${styleText('gray', '➔')}  <${type}>${label}</${type}>\n`;
     }
     return output;
   };
@@ -104,7 +121,7 @@ function filterTargetMap(
     if (storageKey.startsWith('<link:unknown>/')) {
       ERUDIT.log.warn(
         brokenLinkMessage(
-          `Unknown link ${chalk.red(storageKey.replace('<link:unknown>/', ''))}`,
+          `Unknown link ${styleText('red', storageKey.replace('<link:unknown>/', ''))}`,
           metas,
         ),
       );
@@ -136,7 +153,7 @@ function filterTargetMap(
       } catch {
         ERUDIT.log.warn(
           brokenLinkMessage(
-            `Failed to resolve content link ${chalk.red(storageKey.replace('<link:global>/', ''))}`,
+            `Failed to resolve content link ${styleText('red', storageKey.replace('<link:global>/', ''))}`,
             metas,
           ),
         );
@@ -148,25 +165,11 @@ function filterTargetMap(
 }
 
 function globalContentToNavNode(globalContentPath: string) {
-  // Validate the full path (including any $unique suffix) against the link
-  // object that was built from the source files. This catches broken unique
-  // names as well as broken content paths before we ever touch the nav tree.
-  if (builtLinkObject) {
-    const parts = globalContentPath.split('/');
-    let cursor: any = builtLinkObject;
-    let valid = true;
-
-    for (const part of parts) {
-      if (!cursor || typeof cursor !== 'object' || !(part in cursor)) {
-        valid = false;
-        break;
-      }
-      cursor = cursor[part];
-    }
-
-    if (!valid) {
-      throw new Error(`Path not found in \$CONTENT: ${globalContentPath}`);
-    }
+  // Validate the full path (including any $unique suffix) against the complete
+  // set of known valid paths built from source files. This catches broken
+  // unique names and content paths before we ever touch the nav tree.
+  if (builtValidPaths && !builtValidPaths.has(globalContentPath)) {
+    throw new Error(`Path not found in \$CONTENT: ${globalContentPath}`);
   }
 
   const parts = globalContentPath.split('/');
@@ -175,8 +178,7 @@ function globalContentToNavNode(globalContentPath: string) {
     parts.pop();
   }
 
-  // Path already validated against builtLinkObject, so if the exact node
-  // isn't found the last segment must be a topic part — fall back to parent.
+  // If the exact node isn't found the last segment is a topic part — fall back to parent.
   return (
     ERUDIT.contentNav.getNode(parts.join('/')) ??
     ERUDIT.contentNav.getNodeOrThrow(parts.slice(0, -1).join('/'))

package/server/erudit/global.ts

@@ -11,6 +11,7 @@ import type { EruditServerPaths } from './path';
 import type { EruditServerRepository } from './repository';
 
 import { registerProseGlobals } from '#erudit/prose/global';
+import { registerAutoImportGlobals } from '#erudit/autoImports';
 
 export const ERUDIT: {
   buildError: EruditServerBuildError;
@@ -27,7 +28,9 @@ export const ERUDIT: {
   import: EruditServerImporter;
 } = {} as any;
 
-Object.assign(globalThis, {
+(globalThis as any).ERUDIT_GLOBAL = (globalThis as any).ERUDIT_GLOBAL || {};
+
+Object.assign((globalThis as any).ERUDIT_GLOBAL, {
   defineContributor,
   defineSponsor,
   defineCameo,
@@ -40,3 +43,4 @@ Object.assign(globalThis, {
 });
 
 registerProseGlobals();
+registerAutoImportGlobals();

package/server/erudit/importer.ts

@@ -16,6 +16,29 @@ export type EruditServerImporter = Jiti['import'];
 
 export let jiti: Jiti;
 
+/** Cached preamble that destructures all ERUDIT_GLOBAL keys into local vars. */
+let eruditGlobalPreamble: string | undefined;
+
+function getEruditGlobalPreamble(): string {
+  if (eruditGlobalPreamble !== undefined) return eruditGlobalPreamble;
+
+  const eg = (globalThis as any).ERUDIT_GLOBAL;
+  if (!eg || typeof eg !== 'object') {
+    eruditGlobalPreamble = '';
+    return eruditGlobalPreamble;
+  }
+
+  const names = Object.keys(eg).filter((n) => /^[a-zA-Z_$]\w*$/.test(n));
+  if (names.length === 0) {
+    eruditGlobalPreamble = '';
+    return eruditGlobalPreamble;
+  }
+
+  eruditGlobalPreamble =
+    'var { ' + names.join(', ') + ' } = globalThis.ERUDIT_GLOBAL;\n';
+  return eruditGlobalPreamble;
+}
+
 export async function setupServerImporter() {
   const jitiId = ERUDIT.paths.project();
   const defaultJiti = createJiti(jitiId, createBaseJitiOptions());
@@ -38,6 +61,18 @@ export async function setupServerImporter() {
 
       let code = getDefaultCode(opts);
 
+      //
+      // Inject ERUDIT_GLOBAL preamble for project files
+      // Destructures all erudit globals (tags, defineX, jsx runtime, etc.)
+      // into local variables so bare identifiers resolve correctly.
+      //
+      if (filename.startsWith(ERUDIT.paths.project() + '/')) {
+        const preamble = getEruditGlobalPreamble();
+        if (preamble) {
+          code = preamble + code;
+        }
+      }
+
       //
       // Insert IDs in `defineDocument(...)` calls
       //
@@ -58,6 +93,40 @@ export async function setupServerImporter() {
 
       code = insertProblemScriptId(toRelPath(filename), code);
 
+      //
+      // Rebind problem script creator src to this file's path.
+      //
+      // When defineProblemScript is called inside a shared utility file (e.g.
+      // shared.tsx) and then re-exported through an entry file (e.g.
+      // my-script.tsx), jiti injects the *shared* file's path as the scriptSrc.
+      // That makes the client fetch `/api/problemScript/.../shared.js`, which has
+      // no default export and fails at runtime.
+      //
+      // After the module's own code runs we inspect its default export: if it is
+      // a ProblemScriptInstanceCreator (a function whose return value has a
+      // `.generate` method), we wrap it so every created instance gets its
+      // scriptSrc replaced with **this** file's relative path – the actual entry
+      // file the API route will serve.
+      //
+      if (!filename.startsWith(ERUDIT.paths.project() + '/')) {
+        return { code };
+      }
+
+      const relFilePath = toRelPath(filename).replace(/\.[jt]sx?$/, '');
+      code += `
+;(function() {
+  var _eruditFileSrc = ${JSON.stringify(relFilePath)};
+  var _def = exports.default;
+  if (typeof _def !== 'function') return;
+  exports.default = Object.assign(function() {
+    var instance = _def.apply(this, arguments);
+    if (instance && typeof instance === 'object' && typeof instance.generate === 'function') {
+      return Object.assign({}, instance, { scriptSrc: _eruditFileSrc });
+    }
+    return instance;
+  }, _def);
+})();`;
+
       return { code };
     },
   });

package/server/erudit/index.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import type { EruditMode } from '@erudit-js/core/mode';
 
 import { setupServerLogger } from './logger';
@@ -72,7 +72,7 @@ async function setupServer() {
     await setupServerDatabase();
     await setupServerRepository();
     await setupServerContentNav();
-    ERUDIT.log.success(chalk.green('Setup Complete!'));
+    ERUDIT.log.success(styleText('green', 'Setup Complete!'));
 
     await tryServerWatchProject();
     await buildServerErudit();

package/server/erudit/logger.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { brandColorTitle } from '@erudit-js/core/brandTerminal';
 
 interface Logger {
@@ -15,8 +15,12 @@ export type EruditServerLogger = Logger & {
 };
 
 export async function setupServerLogger() {
-  const serverLogger = createLogger(brandColorTitle + ' Server');
-  const serverDebugLogger = createLogger(brandColorTitle + ' Server Debug');
+  const serverLogger = createLogger(
+    `${brandColorTitle}${styleText('gray', ' Server')}`,
+  );
+  const serverDebugLogger = createLogger(
+    `${brandColorTitle}${styleText('gray', ' Server Debug')}`,
+  );
   const debugLogEnabled = !!ERUDIT.config.public.debug.log;
 
   ERUDIT.log = new Proxy(serverLogger, {
@@ -42,32 +46,36 @@ export async function setupServerLogger() {
 }
 
 function createLogger(tag: string): Logger {
-  const formattedTag = chalk.gray(`[${tag}]`);
+  const formattedTag = `${styleText('gray', '[')}${tag}${styleText('gray', ']')}`;
 
   return {
     info(message: any) {
-      console.log(`${formattedTag} ${chalk.blueBright('ℹ')} ${message}`);
+      console.log(`${formattedTag} ${styleText('blueBright', 'ℹ')} ${message}`);
     },
     start(message: any) {
-      console.log(`${formattedTag} ${chalk.magentaBright('◐')} ${message}`);
+      console.log(
+        `${formattedTag} ${styleText('magentaBright', '◐')} ${message}`,
+      );
     },
     success(message: any) {
-      console.log(`${formattedTag} ${chalk.greenBright('✔')} ${message}`);
+      console.log(
+        `${formattedTag} ${styleText('greenBright', '✔')} ${message}`,
+      );
     },
     warn(message: any) {
       console.log(
-        `${formattedTag} ${chalk.bgYellowBright.black(' WARN ')} ${message}`,
+        `${formattedTag} ${styleText(['bgYellowBright', 'black'], ' WARN ')} ${message}`,
       );
     },
     error(message: any) {
       console.log();
       console.log(
-        `${formattedTag} ${chalk.bgRed.whiteBright(' ERROR ')} ${message}`,
+        `${formattedTag} ${styleText(['bgRed', 'whiteBright'], ' ERROR ')} ${message}`,
       );
       console.log();
     },
     stress(message: any) {
-      return chalk.cyanBright(message);
+      return styleText('cyanBright', String(message));
     },
   };
 }

package/server/erudit/reloadSignal.ts

@@ -0,0 +1,14 @@
+type ReloadCallback = () => void;
+
+const subscribers = new Set<ReloadCallback>();
+
+export function subscribeReload(callback: ReloadCallback): () => void {
+  subscribers.add(callback);
+  return () => subscribers.delete(callback);
+}
+
+export function triggerReload(): void {
+  for (const callback of subscribers) {
+    callback();
+  }
+}

package/server/routes/_reload.ts

@@ -0,0 +1,27 @@
+import { isDevLikeMode } from '@erudit-js/core/mode';
+import { subscribeReload } from '../erudit/reloadSignal';
+
+export default defineEventHandler((event) => {
+  if (!isDevLikeMode(ERUDIT.mode)) {
+    throw createError({ statusCode: 404 });
+  }
+
+  const { res, req } = event.node;
+
+  setResponseHeaders(event, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  });
+
+  res.write(': connected\n\n');
+
+  const unsub = subscribeReload(() => {
+    res.write('data: reload\n\n');
+  });
+
+  req.on('close', unsub);
+
+  // Keep connection open
+  return new Promise<void>(() => {});
+});

package/shared/types/contentConnections.ts

@@ -24,6 +24,7 @@ export interface ContentAutoDep extends BaseContentDep {
 export interface ContentHardDep extends BaseContentDep {
   type: 'hard';
   reason: string;
+  uniques?: ContentDepUnique[];
 }
 
 export type ContentDep = ContentAutoDep | ContentHardDep;

package/shared/types/frontContentNav.ts

@@ -1,4 +1,5 @@
 import type { ContentFlags } from '@erudit-js/core/content/flags';
+import type { TopicPart } from '@erudit-js/core/content/topic';
 
 export interface FrontContentNavItemBase {
   shortId: string;
@@ -9,6 +10,7 @@ export interface FrontContentNavItemBase {
 
 export interface FrontContentNavTopic extends FrontContentNavItemBase {
   type: 'topic';
+  parts: TopicPart[];
 }
 
 export interface FrontContentNavPage extends FrontContentNavItemBase {