erudit 4.0.0-dev.5 → 4.0.1

package/server/erudit/db/schema/contentDeps.ts

@@ -1,21 +1,21 @@
-import {
-  integer,
-  primaryKey,
-  sqliteTable,
-  text,
-} from 'drizzle-orm/sqlite-core';
-
-export const contentDeps = sqliteTable(
-  'contentDeps',
-  {
-    fromFullId: text().notNull(),
-    toFullId: text().notNull(),
-    hard: integer({ mode: 'boolean' }).notNull(),
-    reason: text(),
-  },
-  (table) => [
-    primaryKey({
-      columns: [table.fromFullId, table.toFullId],
-    }),
-  ],
-);
+import {
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from 'drizzle-orm/sqlite-core';
+
+export const contentDeps = sqliteTable(
+  'contentDeps',
+  {
+    fromFullId: text().notNull(),
+    toFullId: text().notNull(),
+    hard: integer({ mode: 'boolean' }).notNull(),
+    reason: text(),
+  },
+  (table) => [
+    primaryKey({
+      columns: [table.fromFullId, table.toFullId],
+    }),
+  ],
+);

package/server/erudit/db/schema/contentElementStats.ts

@@ -1,20 +1,20 @@
-import {
-  integer,
-  sqliteTable,
-  text,
-  primaryKey,
-} from 'drizzle-orm/sqlite-core';
-
-export const contentElementStats = sqliteTable(
-  'contentElementStats',
-  {
-    fullId: text().notNull(),
-    schemaName: text().notNull(),
-    count: integer().notNull(),
-  },
-  (table) => [
-    primaryKey({
-      columns: [table.fullId, table.schemaName],
-    }),
-  ],
-);
+import {
+  integer,
+  sqliteTable,
+  text,
+  primaryKey,
+} from 'drizzle-orm/sqlite-core';
+
+export const contentElementStats = sqliteTable(
+  'contentElementStats',
+  {
+    fullId: text().notNull(),
+    schemaName: text().notNull(),
+    count: integer().notNull(),
+  },
+  (table) => [
+    primaryKey({
+      columns: [table.fullId, table.schemaName],
+    }),
+  ],
+);

package/server/erudit/db/schema/contentProseLinks.ts

@@ -1,23 +1,23 @@
-import { sqliteTable, primaryKey, text } from 'drizzle-orm/sqlite-core';
-import { type ProseLink } from '@erudit-js/core/prose/link';
-import { type ContentProseType } from '@erudit-js/core/content/prose';
-
-export const contentProseLinks = sqliteTable(
-  'contentProseLinks',
-  {
-    fromContentId: text().notNull(),
-    fromContentProseType: text().notNull().$type<ContentProseType>(),
-    proseLink: text({ mode: 'json' }).notNull().$type<ProseLink>(),
-    toContentId: text(),
-    toContentProseType: text().$type<ContentProseType>(),
-  },
-  (table) => [
-    primaryKey({
-      columns: [
-        table.fromContentId,
-        table.fromContentProseType,
-        table.proseLink,
-      ],
-    }),
-  ],
-);
+import { sqliteTable, primaryKey, text } from 'drizzle-orm/sqlite-core';
+import { type ProseLink } from '@erudit-js/core/prose/link';
+import { type ContentProseType } from '@erudit-js/core/content/prose';
+
+export const contentProseLinks = sqliteTable(
+  'contentProseLinks',
+  {
+    fromContentId: text().notNull(),
+    fromContentProseType: text().notNull().$type<ContentProseType>(),
+    proseLink: text({ mode: 'json' }).notNull().$type<ProseLink>(),
+    toContentId: text(),
+    toContentProseType: text().$type<ContentProseType>(),
+  },
+  (table) => [
+    primaryKey({
+      columns: [
+        table.fromContentId,
+        table.fromContentProseType,
+        table.proseLink,
+      ],
+    }),
+  ],
+);

package/server/erudit/db/schema/contentSnippets.ts

@@ -1,15 +1,15 @@
-import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { ContentProseType } from '@erudit-js/core/content/prose';
-import type { SnippetData } from '@erudit-js/prose';
-
-export const contentSnippets = sqliteTable('contentSnippets', {
-  snippetId: integer().primaryKey({ autoIncrement: true }),
-  contentFullId: text().notNull(),
-  contentProseType: text().notNull().$type<ContentProseType>(),
-  schemaName: text().notNull(),
-  elementId: text().notNull(),
-  snippetData: text({ mode: 'json' }).$type<SnippetData>().notNull(),
-  search: integer({ mode: 'boolean' }).notNull(),
-  quick: integer({ mode: 'boolean' }).notNull(),
-  seo: integer({ mode: 'boolean' }).notNull(),
-});
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+import type { SnippetData } from '@erudit-js/prose';
+
+export const contentSnippets = sqliteTable('contentSnippets', {
+  snippetId: integer().primaryKey({ autoIncrement: true }),
+  contentFullId: text().notNull(),
+  contentProseType: text().notNull().$type<ContentProseType>(),
+  schemaName: text().notNull(),
+  elementId: text().notNull(),
+  snippetData: text({ mode: 'json' }).$type<SnippetData>().notNull(),
+  search: integer({ mode: 'boolean' }).notNull(),
+  quick: integer({ mode: 'boolean' }).notNull(),
+  seo: integer({ mode: 'boolean' }).notNull(),
+});

package/server/erudit/db/schema/contentToc.ts

@@ -1,16 +1,16 @@
-import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { ResolvedTocItem } from '@erudit-js/prose';
-
-export const contentToc = sqliteTable(
-  'contentToc',
-  {
-    fullId: text().notNull(),
-    topicPart: text(),
-    toc: text({ mode: 'json' }).notNull().$type<ResolvedTocItem[]>(),
-  },
-  (table) => [
-    primaryKey({
-      columns: [table.fullId, table.topicPart],
-    }),
-  ],
-);
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { ResolvedTocItem } from '@erudit-js/prose';
+
+export const contentToc = sqliteTable(
+  'contentToc',
+  {
+    fullId: text().notNull(),
+    topicPart: text(),
+    toc: text({ mode: 'json' }).notNull().$type<ResolvedTocItem[]>(),
+  },
+  (table) => [
+    primaryKey({
+      columns: [table.fullId, table.topicPart],
+    }),
+  ],
+);

package/server/erudit/db/schema/contentUniques.ts

@@ -1,19 +1,19 @@
-import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
-import type { ContentProseType } from '@erudit-js/core/content/prose';
-
-export const contentUniques = sqliteTable(
-  'contentUniques',
-  {
-    contentFullId: text().notNull(),
-    contentProseType: text().notNull().$type<ContentProseType>(),
-    uniqueName: text().notNull(),
-    title: text(),
-    prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
-  },
-  (table) => [
-    primaryKey({
-      columns: [table.contentFullId, table.uniqueName, table.contentProseType],
-    }),
-  ],
-);
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ContentProseType } from '@erudit-js/core/content/prose';
+
+export const contentUniques = sqliteTable(
+  'contentUniques',
+  {
+    contentFullId: text().notNull(),
+    contentProseType: text().notNull().$type<ContentProseType>(),
+    uniqueName: text().notNull(),
+    title: text(),
+    prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+  },
+  (table) => [
+    primaryKey({
+      columns: [table.contentFullId, table.uniqueName, table.contentProseType],
+    }),
+  ],
+);

package/server/erudit/db/schema/contributors.ts

@@ -1,12 +1,12 @@
-import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
-
-export const contributors = sqliteTable('contributors', {
-  contributorId: text().primaryKey(),
-  displayName: text(),
-  short: text(),
-  avatarExtension: text(),
-  editor: integer({ mode: 'boolean' }),
-  links: text({ mode: 'json' }).$type<Record<string, string>>(),
-  description: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
-});
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const contributors = sqliteTable('contributors', {
+  contributorId: text().primaryKey(),
+  displayName: text(),
+  short: text(),
+  avatarExtension: text(),
+  editor: integer({ mode: 'boolean' }),
+  links: text({ mode: 'json' }).$type<Record<string, string>>(),
+  description: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+});

package/server/erudit/db/schema/files.ts

@@ -1,11 +1,11 @@
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { primaryKey } from 'drizzle-orm/sqlite-core';
-
-export const files = sqliteTable(
-  'files',
-  {
-    path: text(),
-    role: text(),
-  },
-  (table) => [primaryKey({ columns: [table.path, table.role] })],
-);
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { primaryKey } from 'drizzle-orm/sqlite-core';
+
+export const files = sqliteTable(
+  'files',
+  {
+    path: text(),
+    role: text(),
+  },
+  (table) => [primaryKey({ columns: [table.path, table.role] })],
+);

package/server/erudit/db/schema/groups.ts

@@ -1,6 +1,6 @@
-import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-export const groups = sqliteTable('groups', {
-  fullId: text().primaryKey(),
-  separator: integer({ mode: 'boolean' }).notNull(),
-});
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const groups = sqliteTable('groups', {
+  fullId: text().primaryKey(),
+  separator: integer({ mode: 'boolean' }).notNull(),
+});

package/server/erudit/db/schema/index.ts

@@ -1,17 +1,17 @@
-export { content } from './content';
-export { contributors } from './contributors';
-export { topics } from './topics';
-export { contentUniques } from './contentUniques';
-export { pages } from './pages';
-export { groups } from './groups';
-export { contentSnippets } from './contentSnippets';
-export { files } from './files';
-export { contentProseLinks } from './contentProseLinks';
-export { problemScripts } from './problemScripts';
-export { contentElementStats } from './contentElementStats';
-export { contentDeps } from './contentDeps';
-export { contentContributions } from './contentContributions';
-export { contentToc } from './contentToc';
-export { cameos } from './cameos';
-export { sponsors } from './sponsors';
-export { news } from './news';
+export { content } from './content';
+export { contributors } from './contributors';
+export { topics } from './topics';
+export { contentUniques } from './contentUniques';
+export { pages } from './pages';
+export { groups } from './groups';
+export { contentSnippets } from './contentSnippets';
+export { files } from './files';
+export { contentProseLinks } from './contentProseLinks';
+export { problemScripts } from './problemScripts';
+export { contentElementStats } from './contentElementStats';
+export { contentDeps } from './contentDeps';
+export { contentContributions } from './contentContributions';
+export { contentToc } from './contentToc';
+export { cameos } from './cameos';
+export { sponsors } from './sponsors';
+export { news } from './news';

package/server/erudit/db/schema/news.ts

@@ -1,7 +1,7 @@
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
-
-export const news = sqliteTable('news', {
-  date: text().primaryKey(),
-  prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
-});
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const news = sqliteTable('news', {
+  date: text().primaryKey(),
+  prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+});

package/server/erudit/db/schema/pages.ts

@@ -1,7 +1,7 @@
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
-
-export const pages = sqliteTable('pages', {
-  fullId: text().primaryKey(),
-  prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
-});
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const pages = sqliteTable('pages', {
+  fullId: text().primaryKey(),
+  prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+});

package/server/erudit/db/schema/problemScripts.ts

@@ -1,14 +1,14 @@
-import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-export const problemScripts = sqliteTable(
-  'problemScripts',
-  {
-    problemScriptSrc: text(),
-    contentFullId: text(),
-  },
-  (table) => [
-    primaryKey({
-      columns: [table.problemScriptSrc, table.contentFullId],
-    }),
-  ],
-);
+import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const problemScripts = sqliteTable(
+  'problemScripts',
+  {
+    problemScriptSrc: text(),
+    contentFullId: text(),
+  },
+  (table) => [
+    primaryKey({
+      columns: [table.problemScriptSrc, table.contentFullId],
+    }),
+  ],
+);

package/server/erudit/db/schema/sponsors.ts

@@ -1,9 +1,9 @@
-import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { Sponsor } from '@erudit-js/core/sponsor';
-
-export const sponsors = sqliteTable('sponsors', {
-  sponsorId: text().primaryKey(),
-  hasMessages: integer({ mode: 'boolean' }).notNull(),
-  avatarExtension: text(),
-  data: text({ mode: 'json' }).notNull().$type<Sponsor>(),
-});
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { Sponsor } from '@erudit-js/core/sponsor';
+
+export const sponsors = sqliteTable('sponsors', {
+  sponsorId: text().primaryKey(),
+  hasMessages: integer({ mode: 'boolean' }).notNull(),
+  avatarExtension: text(),
+  data: text({ mode: 'json' }).notNull().$type<Sponsor>(),
+});

package/server/erudit/db/schema/topics.ts

@@ -1,9 +1,9 @@
-import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
-
-export const topics = sqliteTable('topics', {
-  fullId: text().primaryKey(),
-  article: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
-  summary: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
-  practice: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
-});
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { AnySchema, ProseElement } from '@jsprose/core';
+
+export const topics = sqliteTable('topics', {
+  fullId: text().primaryKey(),
+  article: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+  summary: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+  practice: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+});

package/server/erudit/db/setup.ts

@@ -1,62 +1,62 @@
-import { createRequire } from 'node:module';
-import { readdirSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { drizzle } from 'drizzle-orm/better-sqlite3';
-import Database from 'better-sqlite3';
-
-import * as schema from './schema';
-
-export async function setupServerDatabase() {
-  const buildDir = ERUDIT.paths.project('.erudit');
-  const nowTs = Date.now();
-  const dbFilename = `erudit-${nowTs}.db`;
-  const dbPath = join(buildDir, dbFilename);
-
-  try {
-    for (const f of readdirSync(buildDir)) {
-      const m = f.match(/^erudit-(\d+)\.db$/);
-      if (m && Number(m[1]) < nowTs) {
-        try {
-          unlinkSync(join(buildDir, f));
-        } catch {}
-      }
-    }
-  } catch {}
-
-  const connection = new Database(dbPath);
-
-  const db = drizzle(connection, { schema });
-
-  ERUDIT.db = new Proxy(db, {
-    get(target, prop, receiver) {
-      if (prop === 'connection') {
-        return connection;
-      }
-
-      if (prop === 'schema') {
-        return schema;
-      }
-
-      if (prop === 'path') {
-        return dbPath;
-      }
-
-      return Reflect.get(target, prop, receiver);
-    },
-  }) as any;
-
-  const require = createRequire(import.meta.url);
-  const { generateSQLiteMigration, generateSQLiteDrizzleJson } =
-    require('drizzle-kit/api') as typeof import('drizzle-kit/api');
-
-  const migration = await generateSQLiteMigration(
-    await generateSQLiteDrizzleJson({}),
-    await generateSQLiteDrizzleJson(schema, undefined, 'camelCase'),
-  );
-
-  for (const query of migration) {
-    await ERUDIT.db.run(query);
-  }
-
-  ERUDIT.log.success('Database connection setup complete!');
-}
+import { createRequire } from 'node:module';
+import { readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+
+import * as schema from './schema';
+
+export async function setupServerDatabase() {
+  const buildDir = ERUDIT.paths.project('.erudit');
+  const nowTs = Date.now();
+  const dbFilename = `erudit-${nowTs}.db`;
+  const dbPath = join(buildDir, dbFilename);
+
+  try {
+    for (const f of readdirSync(buildDir)) {
+      const m = f.match(/^erudit-(\d+)\.db$/);
+      if (m && Number(m[1]) < nowTs) {
+        try {
+          unlinkSync(join(buildDir, f));
+        } catch {}
+      }
+    }
+  } catch {}
+
+  const connection = new Database(dbPath);
+
+  const db = drizzle(connection, { schema });
+
+  ERUDIT.db = new Proxy(db, {
+    get(target, prop, receiver) {
+      if (prop === 'connection') {
+        return connection;
+      }
+
+      if (prop === 'schema') {
+        return schema;
+      }
+
+      if (prop === 'path') {
+        return dbPath;
+      }
+
+      return Reflect.get(target, prop, receiver);
+    },
+  }) as any;
+
+  const require = createRequire(import.meta.url);
+  const { generateSQLiteMigration, generateSQLiteDrizzleJson } =
+    require('drizzle-kit/api') as typeof import('drizzle-kit/api');
+
+  const migration = await generateSQLiteMigration(
+    await generateSQLiteDrizzleJson({}),
+    await generateSQLiteDrizzleJson(schema, undefined, 'camelCase'),
+  );
+
+  for (const query of migration) {
+    await ERUDIT.db.run(query);
+  }
+
+  ERUDIT.log.success('Database connection setup complete!');
+}

package/server/erudit/db/types.ts

@@ -1,10 +1,10 @@
-import { LibSQLDatabase } from 'drizzle-orm/libsql';
-import type { Database } from 'better-sqlite3';
-
-import type * as schema from './schema';
-
-export type EruditServerDatabase = LibSQLDatabase<typeof schema> & {
-  path: string;
-  connection: Database;
-  schema: typeof schema;
-};
+import { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { Database } from 'better-sqlite3';
+
+import type * as schema from './schema';
+
+export type EruditServerDatabase = LibSQLDatabase<typeof schema> & {
+  path: string;
+  connection: Database;
+  schema: typeof schema;
+};