@materializecms/db 0.0.0-stage → 0.1.0

package/src/content.js

@@ -0,0 +1,314 @@
+import { randomUUID } from 'node:crypto';
+import { and, asc, count, desc, eq, inArray, isNotNull, like, or, sql } from 'drizzle-orm';
+import { documents, revisions } from './tables.js';
+/** Raised when a slug is already used in the same collection and locale. */
+export class SlugTakenError extends Error {
+    constructor(slug) {
+        super(`The address "${slug}" is already used by another document`);
+        this.name = 'SlugTakenError';
+    }
+}
+const REVISION_MERGE_MS = 5 * 60 * 1000;
+function statusOf(row) {
+    if (!row.publishedAt)
+        return 'draft';
+    return row.hasChanges ? 'changed' : 'published';
+}
+/** The first image found in a document's data (fields first, then blocks, in order). */
+export function firstImage(value, depth = 0) {
+    if (!value || typeof value !== 'object' || depth > 6)
+        return null;
+    const record = value;
+    if (typeof record.src === 'string' && record.src && 'alt' in record)
+        return record.src;
+    for (const child of Array.isArray(value) ? value : Object.values(record)) {
+        const found = firstImage(child, depth + 1);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function toDocument(row) {
+    return {
+        id: row.id,
+        collection: row.collection,
+        locale: row.locale,
+        slug: row.slug,
+        title: row.title,
+        status: statusOf(row),
+        data: row.data,
+        publishedData: row.publishedData ?? null,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        publishedAt: row.publishedAt ?? null,
+        sourceId: row.sourceId ?? null,
+    };
+}
+function isUniqueViolation(error) {
+    const text = String(error?.cause ?? error);
+    return text.includes('UNIQUE constraint failed: documents.collection, documents.locale, documents.slug');
+}
+export function createContentStore(db) {
+    async function addRevision(documentId, kind, data, authorId) {
+        await db.insert(revisions).values({ id: randomUUID(), documentId, kind, data, createdAt: new Date(), authorId });
+    }
+    /**
+     * The admin autosaves while people type: consecutive saves by the same person within a few minutes
+     * update one revision instead of filling the history with near-identical versions.
+     */
+    async function addSaveRevision(documentId, data, authorId) {
+        const [last] = await db
+            .select()
+            .from(revisions)
+            .where(eq(revisions.documentId, documentId))
+            .orderBy(desc(sql `rowid`))
+            .limit(1);
+        const now = new Date();
+        if (last?.kind === 'save' &&
+            last.authorId === (authorId ?? null) &&
+            now.getTime() - last.createdAt.getTime() < REVISION_MERGE_MS) {
+            await db.update(revisions).set({ data, createdAt: now }).where(eq(revisions.id, last.id));
+            return;
+        }
+        await addRevision(documentId, 'save', data, authorId);
+    }
+    async function write(slug, run) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            if (slug && isUniqueViolation(error))
+                throw new SlugTakenError(slug);
+            throw error;
+        }
+    }
+    /** The languages of each listed document's group (original plus translations), by group key. */
+    async function groupsOf(rows) {
+        const keys = [...new Set(rows.map((r) => r.sourceId ?? r.id))];
+        const out = new Map();
+        if (!keys.length)
+            return out;
+        const members = await db
+            .select({ id: documents.id, sourceId: documents.sourceId, locale: documents.locale })
+            .from(documents)
+            .where(or(inArray(documents.id, keys), inArray(documents.sourceId, keys)));
+        for (const m of members) {
+            const key = m.sourceId ?? m.id;
+            out.set(key, [...(out.get(key) ?? []), m.locale]);
+        }
+        return out;
+    }
+    return {
+        async list(collection, options) {
+            const where = and(eq(documents.collection, collection), eq(documents.locale, options.locale), options.publishedOnly ? isNotNull(documents.publishedAt) : undefined, options.search ? like(documents.title, `%${options.search.replace(/[%_]/g, '')}%`) : undefined);
+            const rows = await db
+                .select()
+                .from(documents)
+                .where(where)
+                .orderBy(desc(documents.updatedAt))
+                .limit(Math.min(options.limit ?? 50, 200))
+                .offset(options.offset ?? 0);
+            const [totalRow] = await db.select({ n: count() }).from(documents).where(where);
+            const groups = await groupsOf(rows);
+            return {
+                total: totalRow?.n ?? 0,
+                items: rows.map((r) => ({
+                    id: r.id,
+                    title: r.title,
+                    slug: r.slug,
+                    status: statusOf(r),
+                    updatedAt: r.updatedAt,
+                    publishedAt: r.publishedAt ?? null,
+                    image: firstImage(r.data),
+                    locales: (groups.get(r.sourceId ?? r.id) ?? []).filter((l) => l !== r.locale),
+                })),
+            };
+        },
+        /** Every language version of a document, itself included: the original and its translations. */
+        async translations(id) {
+            const doc = await db.query.documents.findFirst({ where: eq(documents.id, id) });
+            if (!doc)
+                return [];
+            const key = doc.sourceId ?? doc.id;
+            const rows = await db
+                .select()
+                .from(documents)
+                .where(or(eq(documents.id, key), eq(documents.sourceId, key)))
+                .orderBy(asc(documents.createdAt));
+            return rows.map((r) => ({
+                id: r.id,
+                locale: r.locale,
+                title: r.title,
+                status: statusOf(r),
+                sourceId: r.sourceId ?? null,
+            }));
+        },
+        /** Counts per collection and the latest changes across all of them: the panel's home. */
+        async overview(locale, recent = 8) {
+            const counts = await db
+                .select({
+                collection: documents.collection,
+                total: count(),
+                drafts: sql `sum(case when ${documents.publishedAt} is null then 1 else 0 end)`,
+                changed: sql `sum(case when ${documents.publishedAt} is not null and ${documents.hasChanges} then 1 else 0 end)`,
+            })
+                .from(documents)
+                .where(eq(documents.locale, locale))
+                .groupBy(documents.collection);
+            const rows = await db
+                .select()
+                .from(documents)
+                .where(eq(documents.locale, locale))
+                .orderBy(desc(documents.updatedAt), desc(sql `rowid`))
+                .limit(recent);
+            return {
+                counts: counts.map((c) => ({
+                    collection: c.collection,
+                    total: c.total,
+                    drafts: Number(c.drafts ?? 0),
+                    changed: Number(c.changed ?? 0),
+                })),
+                recent: rows.map((r) => ({
+                    id: r.id,
+                    collection: r.collection,
+                    title: r.title,
+                    slug: r.slug,
+                    status: statusOf(r),
+                    updatedAt: r.updatedAt,
+                    publishedAt: r.publishedAt ?? null,
+                    image: firstImage(r.data),
+                    updatedBy: r.updatedBy ?? null,
+                })),
+            };
+        },
+        async get(id) {
+            const row = await db.query.documents.findFirst({ where: eq(documents.id, id) });
+            return row ? toDocument(row) : null;
+        },
+        async getMany(ids) {
+            if (!ids.length)
+                return [];
+            const rows = await db.select().from(documents).where(inArray(documents.id, ids));
+            return rows.map(toDocument);
+        },
+        /** Every published document of a collection (all locales unless one is given), oldest first. */
+        async published(collection, locale) {
+            const rows = await db
+                .select()
+                .from(documents)
+                .where(and(eq(documents.collection, collection), isNotNull(documents.publishedAt), locale ? eq(documents.locale, locale) : undefined))
+                .orderBy(asc(documents.createdAt), asc(sql `rowid`));
+            return rows.map(toDocument);
+        },
+        async getBySlug(collection, slug, locale) {
+            const row = await db.query.documents.findFirst({
+                where: and(eq(documents.collection, collection), eq(documents.slug, slug), eq(documents.locale, locale)),
+            });
+            return row ? toDocument(row) : null;
+        },
+        async create(input) {
+            const now = new Date();
+            const id = randomUUID();
+            await write(input.slug, () => db.insert(documents).values({
+                id,
+                collection: input.collection,
+                locale: input.locale,
+                slug: input.slug,
+                title: input.title,
+                data: input.data,
+                hasChanges: true,
+                createdAt: now,
+                updatedAt: now,
+                createdBy: input.userId,
+                updatedBy: input.userId,
+                sourceId: input.sourceId ?? null,
+            }));
+            await addRevision(id, 'save', input.data, input.userId);
+            return (await this.get(id));
+        },
+        async update(id, input) {
+            const result = await write(input.slug, () => db
+                .update(documents)
+                .set({
+                title: input.title,
+                slug: input.slug,
+                data: input.data,
+                hasChanges: true,
+                updatedAt: new Date(),
+                updatedBy: input.userId,
+            })
+                .where(eq(documents.id, id)));
+            if (result.rowsAffected === 0)
+                return null;
+            await addSaveRevision(id, input.data, input.userId);
+            return this.get(id);
+        },
+        /** Makes the current draft live; `data` is the validated form of the draft, when the caller has one. */
+        async publish(id, userId, data) {
+            const current = await this.get(id);
+            if (!current)
+                return null;
+            const live = data ?? current.data;
+            const now = new Date();
+            await db
+                .update(documents)
+                .set({ publishedData: live, publishedAt: now, hasChanges: false, updatedAt: now, updatedBy: userId })
+                .where(eq(documents.id, id));
+            await addRevision(id, 'publish', live, userId);
+            return this.get(id);
+        },
+        /** Takes the document off the live site; the draft stays. */
+        async unpublish(id, userId) {
+            const result = await db
+                .update(documents)
+                .set({ publishedData: null, publishedAt: null, hasChanges: true, updatedAt: new Date(), updatedBy: userId })
+                .where(eq(documents.id, id));
+            return result.rowsAffected ? this.get(id) : null;
+        },
+        async remove(id) {
+            const result = await db.delete(documents).where(eq(documents.id, id));
+            if (!result.rowsAffected)
+                return false;
+            // Translations of a deleted original stay together: the oldest becomes their original.
+            const orphans = await db
+                .select({ id: documents.id })
+                .from(documents)
+                .where(eq(documents.sourceId, id))
+                .orderBy(asc(documents.createdAt));
+            const [first, ...rest] = orphans;
+            if (first) {
+                await db.update(documents).set({ sourceId: null }).where(eq(documents.id, first.id));
+                if (rest.length)
+                    await db
+                        .update(documents)
+                        .set({ sourceId: first.id })
+                        .where(inArray(documents.id, rest.map((r) => r.id)));
+            }
+            return true;
+        },
+        async revisions(documentId) {
+            const rows = await db
+                .select()
+                .from(revisions)
+                .where(eq(revisions.documentId, documentId))
+                // rowid follows insertion order, so revisions written in the same millisecond stay ordered.
+                .orderBy(desc(sql `rowid`))
+                .limit(100);
+            return rows.map((r) => ({ id: r.id, kind: r.kind, data: r.data, createdAt: r.createdAt, authorId: r.authorId }));
+        },
+        /** Copies an old version back into the draft, recorded as a new revision. */
+        async restore(documentId, revisionId, userId) {
+            const revision = await db.query.revisions.findFirst({
+                where: and(eq(revisions.id, revisionId), eq(revisions.documentId, documentId)),
+            });
+            if (!revision)
+                return null;
+            await db
+                .update(documents)
+                .set({ data: revision.data, hasChanges: true, updatedAt: new Date(), updatedBy: userId })
+                .where(eq(documents.id, documentId));
+            await addRevision(documentId, 'restore', revision.data, userId);
+            return this.get(documentId);
+        },
+    };
+}

package/src/database.d.ts

@@ -0,0 +1,19 @@
+import { type Client } from '@libsql/client';
+import { type LibSQLDatabase } from 'drizzle-orm/libsql';
+import * as tables from './tables.ts';
+export type Db = LibSQLDatabase<typeof tables>;
+export interface Database {
+    db: Db;
+    client: Client;
+    /** Where it lives: `file:…`, `:memory:` or a hosted libSQL URL. */
+    url: string;
+    close: () => void;
+}
+/**
+ * Opens a database: `file:path.db` for local SQLite (the default), `:memory:` for tests,
+ * or a libSQL / Turso URL for hosted setups. Pending migrations run automatically.
+ */
+export declare function openDatabase(options: {
+    url: string;
+    authToken?: string;
+}): Promise<Database>;

package/src/database.js

@@ -0,0 +1,35 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { createClient } from '@libsql/client';
+import { drizzle } from 'drizzle-orm/libsql';
+import * as tables from './tables.js';
+import { MIGRATIONS } from './tables.js';
+/**
+ * Opens a database: `file:path.db` for local SQLite (the default), `:memory:` for tests,
+ * or a libSQL / Turso URL for hosted setups. Pending migrations run automatically.
+ */
+export async function openDatabase(options) {
+    if (options.url.startsWith('file:')) {
+        await mkdir(dirname(options.url.slice('file:'.length)), { recursive: true });
+    }
+    const client = createClient({ url: options.url, authToken: options.authToken });
+    await client.execute('PRAGMA foreign_keys = ON');
+    if (options.url.startsWith('file:'))
+        await client.execute('PRAGMA journal_mode = WAL');
+    await migrate(client);
+    return { db: drizzle(client, { schema: tables }), client, url: options.url, close: () => client.close() };
+}
+async function migrate(client) {
+    await client.execute('CREATE TABLE IF NOT EXISTS _materialize_schema (version INTEGER NOT NULL)');
+    const row = (await client.execute('SELECT version FROM _materialize_schema LIMIT 1')).rows[0];
+    const current = row ? Number(row.version) : 0;
+    for (let v = current; v < MIGRATIONS.length; v++) {
+        const steps = MIGRATIONS[v] ?? [];
+        await client.batch([
+            ...steps,
+            current === 0 && v === 0
+                ? { sql: 'INSERT INTO _materialize_schema (version) VALUES (?)', args: [v + 1] }
+                : { sql: 'UPDATE _materialize_schema SET version = ?', args: [v + 1] },
+        ], 'write');
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,8 @@
+export { type ActivityEntry, type ActivityStore, createActivityStore } from './activity.ts';
+export { type ApiToken, type AuthStore, createAuthStore, type DeviceSession, EmailTakenError, type Invite, type Member, type Role, TOKEN_PREFIX, type User, } from './auth.ts';
+export { type Comment, type CommentStore, createCommentStore } from './comments.ts';
+export { type ContentStore, createContentStore, type DocumentStatus, type DocumentSummary, type ListOptions, type Revision, SlugTakenError, type StoredDocument, type Translation, } from './content.ts';
+export { type Database, type Db, openDatabase } from './database.ts';
+export { createMediaStore, type MediaAsset, type MediaStore } from './media.ts';
+export { createSettingsStore, type SettingsStore } from './settings.ts';
+export { createSubmissionStore, type Submission, type SubmissionStore } from './submissions.ts';

package/src/index.js

@@ -0,0 +1,8 @@
+export { createActivityStore } from './activity.js';
+export { createAuthStore, EmailTakenError, TOKEN_PREFIX, } from './auth.js';
+export { createCommentStore } from './comments.js';
+export { createContentStore, SlugTakenError, } from './content.js';
+export { openDatabase } from './database.js';
+export { createMediaStore } from './media.js';
+export { createSettingsStore } from './settings.js';
+export { createSubmissionStore } from './submissions.js';

package/src/media.d.ts

@@ -0,0 +1,36 @@
+import type { Db } from './database.ts';
+import { media } from './tables.ts';
+export type MediaAsset = typeof media.$inferSelect;
+export declare function createMediaStore(db: Db): {
+    create(input: Omit<MediaAsset, 'id' | 'createdAt' | 'alt'> & {
+        alt?: string;
+    }): Promise<MediaAsset>;
+    list(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: {
+            id: string;
+            key: string;
+            filename: string;
+            mime: string;
+            size: number;
+            width: number | null;
+            height: number | null;
+            alt: string;
+            createdAt: Date;
+            createdBy: string | null;
+        }[];
+        total: number;
+    }>;
+    get(id: string): Promise<MediaAsset | null>;
+    getByKey(key: string): Promise<MediaAsset | null>;
+    update(id: string, input: {
+        alt: string;
+    }): Promise<MediaAsset | null>;
+    remove(id: string): Promise<boolean>;
+    /** How many documents mention the file, in their draft or published version. */
+    usage(key: string): Promise<number>;
+};
+export type MediaStore = ReturnType<typeof createMediaStore>;

package/src/media.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'node:crypto';
+import { count, desc, eq, like, or, sql } from 'drizzle-orm';
+import { documents, media } from './tables.js';
+export function createMediaStore(db) {
+    return {
+        async create(input) {
+            const row = { id: randomUUID(), createdAt: new Date(), alt: '', ...input };
+            await db.insert(media).values(row);
+            return row;
+        },
+        async list(options = {}) {
+            const term = options.search?.replace(/[%_]/g, '');
+            const where = term ? or(like(media.filename, `%${term}%`), like(media.alt, `%${term}%`)) : undefined;
+            const items = await db
+                .select()
+                .from(media)
+                .where(where)
+                .orderBy(desc(media.createdAt), desc(sql `rowid`))
+                .limit(Math.min(options.limit ?? 60, 200))
+                .offset(options.offset ?? 0);
+            const [total] = await db.select({ n: count() }).from(media).where(where);
+            return { items, total: total?.n ?? 0 };
+        },
+        async get(id) {
+            return (await db.query.media.findFirst({ where: eq(media.id, id) })) ?? null;
+        },
+        async getByKey(key) {
+            return (await db.query.media.findFirst({ where: eq(media.key, key) })) ?? null;
+        },
+        async update(id, input) {
+            await db.update(media).set({ alt: input.alt }).where(eq(media.id, id));
+            return this.get(id);
+        },
+        async remove(id) {
+            return (await db.delete(media).where(eq(media.id, id))).rowsAffected > 0;
+        },
+        /** How many documents mention the file, in their draft or published version. */
+        async usage(key) {
+            const needle = `%/media/${key.replace(/[%_]/g, '')}%`;
+            const [row] = await db
+                .select({ n: count() })
+                .from(documents)
+                .where(or(like(documents.data, needle), like(documents.publishedData, needle)));
+            return row?.n ?? 0;
+        },
+    };
+}

package/src/settings.d.ts

@@ -0,0 +1,7 @@
+import type { Db } from './database.ts';
+/** Site-wide values by key (the design theme, for one), saved as JSON. */
+export declare function createSettingsStore(db: Db): {
+    get<T = unknown>(key: string): Promise<T | null>;
+    set(key: string, value: unknown, userId?: string): Promise<void>;
+};
+export type SettingsStore = ReturnType<typeof createSettingsStore>;

package/src/settings.js

@@ -0,0 +1,21 @@
+import { eq } from 'drizzle-orm';
+import { settings } from './tables.js';
+/** Site-wide values by key (the design theme, for one), saved as JSON. */
+export function createSettingsStore(db) {
+    return {
+        async get(key) {
+            const row = await db.query.settings.findFirst({ where: eq(settings.key, key) });
+            return row?.value ?? null;
+        },
+        async set(key, value, userId) {
+            const row = { key, value, updatedAt: new Date(), updatedBy: userId ?? null };
+            await db
+                .insert(settings)
+                .values(row)
+                .onConflictDoUpdate({
+                target: settings.key,
+                set: { value, updatedAt: row.updatedAt, updatedBy: row.updatedBy },
+            });
+        },
+    };
+}

package/src/submissions.d.ts

@@ -0,0 +1,27 @@
+import type { Db } from './database.ts';
+export interface Submission {
+    id: string;
+    form: string;
+    page: string;
+    data: Record<string, string>;
+    read: boolean;
+    mailed: boolean;
+    createdAt: Date;
+}
+/** Messages from the site's forms: kept even when email is not set up, so nothing is lost. */
+export declare function createSubmissionStore(db: Db): {
+    add(input: {
+        form: string;
+        page: string;
+        data: Record<string, string>;
+    }): Promise<Submission>;
+    list(limit?: number, offset?: number): Promise<{
+        items: Submission[];
+        total: number;
+        unread: number;
+    }>;
+    markMailed(id: string): Promise<void>;
+    markRead(id: string, read?: boolean): Promise<void>;
+    remove(id: string): Promise<void>;
+};
+export type SubmissionStore = ReturnType<typeof createSubmissionStore>;

package/src/submissions.js

@@ -0,0 +1,28 @@
+import { randomUUID } from 'node:crypto';
+import { count, desc, eq } from 'drizzle-orm';
+import { submissions } from './tables.js';
+/** Messages from the site's forms: kept even when email is not set up, so nothing is lost. */
+export function createSubmissionStore(db) {
+    return {
+        async add(input) {
+            const row = { id: randomUUID(), ...input, read: false, mailed: false, createdAt: new Date() };
+            await db.insert(submissions).values(row);
+            return row;
+        },
+        async list(limit = 50, offset = 0) {
+            const items = await db.select().from(submissions).orderBy(desc(submissions.createdAt)).limit(limit).offset(offset);
+            const [all] = await db.select({ n: count() }).from(submissions);
+            const [unread] = await db.select({ n: count() }).from(submissions).where(eq(submissions.read, false));
+            return { items, total: all?.n ?? 0, unread: unread?.n ?? 0 };
+        },
+        async markMailed(id) {
+            await db.update(submissions).set({ mailed: true }).where(eq(submissions.id, id));
+        },
+        async markRead(id, read = true) {
+            await db.update(submissions).set({ read }).where(eq(submissions.id, id));
+        },
+        async remove(id) {
+            await db.delete(submissions).where(eq(submissions.id, id));
+        },
+    };
+}