erudit 4.0.0-dev.4 → 4.0.0

package/server/erudit/logger.ts

@@ -1,77 +1,73 @@
-import chalk from 'chalk';
-import { brandColorTitle } from '@erudit-js/core/brandTerminal';
-
-interface Logger {
-    info(message: any): void;
-    start(message: any): void;
-    success(message: any): void;
-    warn(message: any): void;
-    error(message: any): void;
-    stress(message: any): string;
-}
-
-export type EruditServerLogger = Logger & {
-    debug: Logger;
-};
-
-export async function setupServerLogger() {
-    const serverLogger = createLogger(brandColorTitle + ' Server');
-    const serverDebugLogger = createLogger(brandColorTitle + ' Server Debug');
-    const debugLogEnabled = !!ERUDIT.config.public.project.debug.log;
-
-    ERUDIT.log = new Proxy(serverLogger, {
-        get(target, prop) {
-            if (prop === 'debug') {
-                if (!debugLogEnabled) {
-                    return new Proxy(
-                        {},
-                        {
-                            get() {
-                                return () => {};
-                            },
-                        },
-                    );
-                }
-                return serverDebugLogger;
-            }
-            return target[prop as keyof typeof target];
-        },
-    }) as EruditServerLogger;
-
-    ERUDIT.log.success('Logger setup complete!');
-}
-
-function createLogger(tag: string): Logger {
-    const formattedTag = chalk.gray(`[${tag}]`);
-
-    return {
-        info(message: any) {
-            console.log(`${formattedTag} ${chalk.blueBright('ℹ')} ${message}`);
-        },
-        start(message: any) {
-            console.log(
-                `${formattedTag} ${chalk.magentaBright('◐')} ${message}`,
-            );
-        },
-        success(message: any) {
-            console.log(
-                `${formattedTag} ${chalk.greenBright('✔')} ${message}`,
-            );
-        },
-        warn(message: any) {
-            console.log(
-                `${formattedTag} ${chalk.bgYellowBright.black(' WARN ')} ${message}`,
-            );
-        },
-        error(message: any) {
-            console.log();
-            console.log(
-                `${formattedTag} ${chalk.bgRed.whiteBright(' ERROR ')} ${message}`,
-            );
-            console.log();
-        },
-        stress(message: any) {
-            return chalk.cyanBright(message);
-        },
-    };
-}
+import chalk from 'chalk';
+import { brandColorTitle } from '@erudit-js/core/brandTerminal';
+
+interface Logger {
+  info(message: any): void;
+  start(message: any): void;
+  success(message: any): void;
+  warn(message: any): void;
+  error(message: any): void;
+  stress(message: any): string;
+}
+
+export type EruditServerLogger = Logger & {
+  debug: Logger;
+};
+
+export async function setupServerLogger() {
+  const serverLogger = createLogger(brandColorTitle + ' Server');
+  const serverDebugLogger = createLogger(brandColorTitle + ' Server Debug');
+  const debugLogEnabled = !!ERUDIT.config.public.debug.log;
+
+  ERUDIT.log = new Proxy(serverLogger, {
+    get(target, prop) {
+      if (prop === 'debug') {
+        if (!debugLogEnabled) {
+          return new Proxy(
+            {},
+            {
+              get() {
+                return () => {};
+              },
+            },
+          );
+        }
+        return serverDebugLogger;
+      }
+      return target[prop as keyof typeof target];
+    },
+  }) as EruditServerLogger;
+
+  ERUDIT.log.success('Logger setup complete!');
+}
+
+function createLogger(tag: string): Logger {
+  const formattedTag = chalk.gray(`[${tag}]`);
+
+  return {
+    info(message: any) {
+      console.log(`${formattedTag} ${chalk.blueBright('ℹ')} ${message}`);
+    },
+    start(message: any) {
+      console.log(`${formattedTag} ${chalk.magentaBright('◐')} ${message}`);
+    },
+    success(message: any) {
+      console.log(`${formattedTag} ${chalk.greenBright('✔')} ${message}`);
+    },
+    warn(message: any) {
+      console.log(
+        `${formattedTag} ${chalk.bgYellowBright.black(' WARN ')} ${message}`,
+      );
+    },
+    error(message: any) {
+      console.log();
+      console.log(
+        `${formattedTag} ${chalk.bgRed.whiteBright(' ERROR ')} ${message}`,
+      );
+      console.log();
+    },
+    stress(message: any) {
+      return chalk.cyanBright(message);
+    },
+  };
+}

package/server/erudit/news/build.ts

@@ -1,114 +1,112 @@
-import { existsSync } from 'node:fs';
-import { inArray } from 'drizzle-orm';
-import { globSync } from 'glob';
-import type { AnySchema, RawElement } from '@jsprose/core';
-
-import { resolveEruditProse } from '../prose/repository/resolve';
-
-let initialBuild = true;
-
-const newsRoot = () => `${ERUDIT.config.paths.project}/news`;
-
-export async function buildNews() {
-    ERUDIT.log.debug.start('Building news...');
-
-    const isInitial = initialBuild;
-    initialBuild = false;
-
-    const newsFilenames = collectNewsFilenames(isInitial);
-
-    if (!newsFilenames.size) {
-        ERUDIT.log.info(
-            isInitial
-                ? 'Skipping news — no news found.'
-                : 'Skipping news — nothing changed.',
-        );
-        return;
-    }
-
-    for (const filename of newsFilenames) {
-        await cleanupNews(filename);
-    }
-
-    const existingFilenames = [...newsFilenames].filter((filename) =>
-        existsSync(`${newsRoot()}/${filename}`),
-    );
-
-    if (!existingFilenames.length) {
-        return;
-    }
-
-    for (const filename of existingFilenames) {
-        await buildNewsItem(filename);
-    }
-
-    ERUDIT.log.success(
-        isInitial
-            ? `News build complete! (${ERUDIT.log.stress(newsFilenames.size)})`
-            : `News updated: ${ERUDIT.log.stress(existingFilenames.join(', '))}`,
-    );
-}
-
-//
-//
-//
-
-function collectNewsFilenames(initial: boolean): Set<string> {
-    if (initial) {
-        return new Set(
-            globSync(`[0-9][0-9][0-9][0-9].[0-9][0-9].[0-9][0-9].tsx`, {
-                posix: true,
-                cwd: newsRoot(),
-            }),
-        );
-    }
-
-    const filenames = new Set<string>();
-
-    for (const file of ERUDIT.changedFiles.values()) {
-        if (!file.startsWith(`${newsRoot()}/`)) continue;
-        const relativePath = file.replace(`${newsRoot()}/`, '');
-
-        if (relativePath.match(/^[0-9]{4}\.[0-9]{2}\.[0-9]{2}\.tsx$/)) {
-            filenames.add(relativePath);
-        }
-    }
-
-    return filenames;
-}
-
-async function cleanupNews(filename: string) {
-    await ERUDIT.db
-        .delete(ERUDIT.db.schema.news)
-        .where(
-            inArray(ERUDIT.db.schema.news.date, [filename.replace('.tsx', '')]),
-        );
-}
-
-async function buildNewsItem(filename: string) {
-    ERUDIT.log.debug.start(
-        `Building news item ${ERUDIT.log.stress(filename)}...`,
-    );
-
-    let newsModule: { default: RawElement<AnySchema> } | undefined;
-
-    try {
-        newsModule = await ERUDIT.import(`${newsRoot()}/${filename}`);
-    } catch (err) {
-        ERUDIT.log.error(`Failed to load news item ${filename}:`);
-        console.error(err);
-        return;
-    }
-
-    if (!newsModule?.default) {
-        ERUDIT.log.error(`No default export in news item ${filename}`);
-        return;
-    }
-
-    const resolvedProse = await resolveEruditProse(newsModule.default, false);
-
-    await ERUDIT.db.insert(ERUDIT.db.schema.news).values({
-        date: filename.replace('.tsx', ''),
-        prose: resolvedProse.proseElement,
-    });
-}
+import { existsSync } from 'node:fs';
+import { inArray } from 'drizzle-orm';
+import { globSync } from 'glob';
+import type { AnySchema, RawElement } from '@jsprose/core';
+
+import { resolveEruditProse } from '../prose/repository/resolve';
+
+let initialBuild = true;
+
+const newsRoot = () => ERUDIT.paths.project(`news`);
+
+export async function buildNews() {
+  ERUDIT.log.debug.start('Building news...');
+
+  const isInitial = initialBuild;
+  initialBuild = false;
+
+  const newsFilenames = collectNewsFilenames(isInitial);
+
+  if (!newsFilenames.size) {
+    ERUDIT.log.info(
+      isInitial
+        ? 'Skipping news — no news found.'
+        : 'Skipping news — nothing changed.',
+    );
+    return;
+  }
+
+  for (const filename of newsFilenames) {
+    await cleanupNews(filename);
+  }
+
+  const existingFilenames = [...newsFilenames].filter((filename) =>
+    existsSync(`${newsRoot()}/${filename}`),
+  );
+
+  if (!existingFilenames.length) {
+    return;
+  }
+
+  for (const filename of existingFilenames) {
+    await buildNewsItem(filename);
+  }
+
+  ERUDIT.log.success(
+    isInitial
+      ? `News build complete! (${ERUDIT.log.stress(newsFilenames.size)})`
+      : `News updated: ${ERUDIT.log.stress(existingFilenames.join(', '))}`,
+  );
+}
+
+//
+//
+//
+
+function collectNewsFilenames(initial: boolean): Set<string> {
+  if (initial) {
+    return new Set(
+      globSync(`[0-9][0-9][0-9][0-9].[0-9][0-9].[0-9][0-9].tsx`, {
+        posix: true,
+        cwd: newsRoot(),
+      }),
+    );
+  }
+
+  const filenames = new Set<string>();
+
+  for (const file of ERUDIT.changedFiles.values()) {
+    if (!file.startsWith(`${newsRoot()}/`)) continue;
+    const relativePath = file.replace(`${newsRoot()}/`, '');
+
+    if (relativePath.match(/^[0-9]{4}\.[0-9]{2}\.[0-9]{2}\.tsx$/)) {
+      filenames.add(relativePath);
+    }
+  }
+
+  return filenames;
+}
+
+async function cleanupNews(filename: string) {
+  await ERUDIT.db
+    .delete(ERUDIT.db.schema.news)
+    .where(inArray(ERUDIT.db.schema.news.date, [filename.replace('.tsx', '')]));
+}
+
+async function buildNewsItem(filename: string) {
+  ERUDIT.log.debug.start(
+    `Building news item ${ERUDIT.log.stress(filename)}...`,
+  );
+
+  let newsModule: { default: RawElement<AnySchema> } | undefined;
+
+  try {
+    newsModule = await ERUDIT.import(`${newsRoot()}/${filename}`);
+  } catch (err) {
+    ERUDIT.log.error(`Failed to load news item ${filename}:`);
+    console.error(err);
+    return;
+  }
+
+  if (!newsModule?.default) {
+    ERUDIT.log.error(`No default export in news item ${filename}`);
+    return;
+  }
+
+  const resolvedProse = await resolveEruditProse(newsModule.default, false);
+
+  await ERUDIT.db.insert(ERUDIT.db.schema.news).values({
+    date: filename.replace('.tsx', ''),
+    prose: resolvedProse.proseElement,
+  });
+}

package/server/erudit/news/repository/batch.ts

@@ -1,61 +1,61 @@
-import { count } from 'drizzle-orm';
-
-const newsNumberPerBatch = 20;
-
-export async function countNewsBatches(): Promise<number> {
-    const newsTotal = await ERUDIT.db
-        .select({ count: count() })
-        .from(ERUDIT.db.schema.news)
-        .then((result) => result[0].count);
-
-    return Math.ceil(newsTotal / newsNumberPerBatch);
-}
-
-export async function getNewsNextBatch(index: number): Promise<NewsBatch> {
-    const newsTotal = await ERUDIT.db
-        .select({ count: count() })
-        .from(ERUDIT.db.schema.news)
-        .then((result) => result[0].count);
-
-    const dbNews = await ERUDIT.db.query.news.findMany({
-        columns: {
-            date: true,
-            prose: true,
-        },
-        orderBy: (news, { desc }) => [desc(news.date)],
-        limit: newsNumberPerBatch,
-        offset: index * newsNumberPerBatch,
-    });
-
-    const items: NewsItem[] = [];
-
-    for (const dbNewsItem of dbNews) {
-        const date = dbNewsItem.date;
-        const finalizedProse = await ERUDIT.repository.prose.finalize(
-            dbNewsItem.prose,
-        );
-
-        const item: NewsItem = {
-            date,
-            content: finalizedProse,
-        };
-
-        items.push(item);
-    }
-
-    const hasNext = (index + 1) * newsNumberPerBatch < newsTotal;
-
-    const batch: NewsBatch = {
-        items,
-    };
-
-    if (hasNext) {
-        batch.nextIndex = index + 1;
-    }
-
-    if (index === 0) {
-        batch.total = newsTotal;
-    }
-
-    return batch;
-}
+import { count } from 'drizzle-orm';
+
+const newsNumberPerBatch = 20;
+
+export async function countNewsBatches(): Promise<number> {
+  const newsTotal = await ERUDIT.db
+    .select({ count: count() })
+    .from(ERUDIT.db.schema.news)
+    .then((result) => result[0].count);
+
+  return Math.ceil(newsTotal / newsNumberPerBatch);
+}
+
+export async function getNewsNextBatch(index: number): Promise<NewsBatch> {
+  const newsTotal = await ERUDIT.db
+    .select({ count: count() })
+    .from(ERUDIT.db.schema.news)
+    .then((result) => result[0].count);
+
+  const dbNews = await ERUDIT.db.query.news.findMany({
+    columns: {
+      date: true,
+      prose: true,
+    },
+    orderBy: (news, { desc }) => [desc(news.date)],
+    limit: newsNumberPerBatch,
+    offset: index * newsNumberPerBatch,
+  });
+
+  const items: NewsItem[] = [];
+
+  for (const dbNewsItem of dbNews) {
+    const date = dbNewsItem.date;
+    const finalizedProse = await ERUDIT.repository.prose.finalize(
+      dbNewsItem.prose,
+    );
+
+    const item: NewsItem = {
+      date,
+      content: finalizedProse,
+    };
+
+    items.push(item);
+  }
+
+  const hasNext = (index + 1) * newsNumberPerBatch < newsTotal;
+
+  const batch: NewsBatch = {
+    items,
+  };
+
+  if (hasNext) {
+    batch.nextIndex = index + 1;
+  }
+
+  if (index === 0) {
+    batch.total = newsTotal;
+  }
+
+  return batch;
+}

package/server/erudit/path.ts

@@ -0,0 +1,19 @@
+import { sn } from 'unslash';
+
+export interface EruditServerPaths {
+  erudit(...paths: string[]): string;
+  project(...paths: string[]): string;
+}
+
+export async function setupServerPaths() {
+  const runtimeConfig = useRuntimeConfig();
+
+  const pathConstructor = (basePart: string) => {
+    return (...parts: string[]) => sn(...[basePart, ...parts]);
+  };
+
+  ERUDIT.paths = {
+    erudit: pathConstructor(runtimeConfig.eruditPath),
+    project: pathConstructor(runtimeConfig.projectPath),
+  };
+}

package/server/erudit/prose/repository/finalize.ts

@@ -1,68 +1,68 @@
-import {
-    fillStorage,
-    isProseElement,
-    PROSE_REGISTRY,
-    type AnySchema,
-    type FinalizedProse,
-    type GenericStorage,
-    type ProseElement,
-} from '@jsprose/core';
-import { imageSchema } from '@erudit-js/prose/elements/image/core';
-import { videoSchema } from '@erudit-js/prose/elements/video/core';
-import { calloutSchema } from '@erudit-js/prose/elements/callout/core';
-import {
-    referenceSchema,
-    refSchema,
-} from '@erudit-js/prose/elements/link/reference/core';
-import {
-    dependencySchema,
-    depSchema,
-} from '@erudit-js/prose/elements/link/dependency/core';
-import { problemSchema } from '@erudit-js/prose/elements/problem/problem';
-import { subProblemSchema } from '@erudit-js/prose/elements/problem/problems';
-
-import { createImageStorage } from '../storage/image';
-import { createVideoStorage } from '../storage/video';
-import { createCalloutStorage } from '../storage/callout';
-import { createLinkStorage } from '../storage/link';
-import { createProblemScriptStorage } from '../storage/problemScript';
-
-export async function finalizeProse(
-    proseElement: ProseElement<AnySchema>,
-): Promise<FinalizedProse> {
-    const storage: GenericStorage = {};
-
-    await fillStorage({
-        storage,
-        proseElement,
-        storageCreators: PROSE_REGISTRY.getStorageCreators(),
-        step: async (element) => {
-            switch (true) {
-                case isProseElement(element, imageSchema):
-                    await createImageStorage(element, storage);
-                    break;
-                case isProseElement(element, videoSchema):
-                    await createVideoStorage(element, storage);
-                    break;
-                case isProseElement(element, calloutSchema):
-                    await createCalloutStorage(element, storage);
-                    break;
-                case isProseElement(element, refSchema):
-                case isProseElement(element, referenceSchema):
-                case isProseElement(element, depSchema):
-                case isProseElement(element, dependencySchema):
-                    await createLinkStorage(element, storage);
-                    break;
-                case isProseElement(element, problemSchema):
-                case isProseElement(element, subProblemSchema):
-                    await createProblemScriptStorage(element, storage);
-                    break;
-            }
-        },
-    });
-
-    return {
-        proseElement,
-        storage,
-    };
-}
+import {
+  fillStorage,
+  isProseElement,
+  PROSE_REGISTRY,
+  type AnySchema,
+  type FinalizedProse,
+  type GenericStorage,
+  type ProseElement,
+} from '@jsprose/core';
+import { imageSchema } from '@erudit-js/prose/elements/image/core';
+import { videoSchema } from '@erudit-js/prose/elements/video/core';
+import { calloutSchema } from '@erudit-js/prose/elements/callout/core';
+import {
+  referenceSchema,
+  refSchema,
+} from '@erudit-js/prose/elements/link/reference/core';
+import {
+  dependencySchema,
+  depSchema,
+} from '@erudit-js/prose/elements/link/dependency/core';
+import { problemSchema } from '@erudit-js/prose/elements/problem/problem';
+import { subProblemSchema } from '@erudit-js/prose/elements/problem/problems';
+
+import { createImageStorage } from '../storage/image';
+import { createVideoStorage } from '../storage/video';
+import { createCalloutStorage } from '../storage/callout';
+import { createLinkStorage } from '../storage/link';
+import { createProblemScriptStorage } from '../storage/problemScript';
+
+export async function finalizeProse(
+  proseElement: ProseElement<AnySchema>,
+): Promise<FinalizedProse> {
+  const storage: GenericStorage = {};
+
+  await fillStorage({
+    storage,
+    proseElement,
+    storageCreators: PROSE_REGISTRY.getStorageCreators(),
+    step: async (element) => {
+      switch (true) {
+        case isProseElement(element, imageSchema):
+          await createImageStorage(element, storage);
+          break;
+        case isProseElement(element, videoSchema):
+          await createVideoStorage(element, storage);
+          break;
+        case isProseElement(element, calloutSchema):
+          await createCalloutStorage(element, storage);
+          break;
+        case isProseElement(element, refSchema):
+        case isProseElement(element, referenceSchema):
+        case isProseElement(element, depSchema):
+        case isProseElement(element, dependencySchema):
+          await createLinkStorage(element, storage);
+          break;
+        case isProseElement(element, problemSchema):
+        case isProseElement(element, subProblemSchema):
+          await createProblemScriptStorage(element, storage);
+          break;
+      }
+    },
+  });
+
+  return {
+    proseElement,
+    storage,
+  };
+}