@manablox/db 0.1.0 → 0.2.0

package/src/repositories/content.ts

@@ -1,7 +1,8 @@
 import { type ContentStatus, type ContentTypeRegistry, ManabloxError } from '@manablox/core';
 import { and, eq, getTableColumns, inArray, type SQL, sql } from 'drizzle-orm';
-import type { Database } from '../client.js';
+import type { Executor } from '../client.js';
 import { idToLabel } from '../columns.js';
+import { type Paginated, paginate } from '../pagination.js';
 import {
   buildContentWhere,
   buildOrderBy,
@@ -15,9 +16,9 @@ import {
   contentVersions,
   publishedContents,
   spaces,
-} from '../schema.js';
+} from '../schema/index.js';
 
-export type { ContentFilter, ContentSort, Pagination };
+export type { ContentFilter, ContentSort, Paginated, Pagination };
 
 export interface ContentWriteData {
   id?: string | undefined;
@@ -30,7 +31,6 @@ export interface ContentWriteData {
   slug: string;
   fields: Record<string, unknown>;
   searchText?: string | undefined;
-  visibleInMenu?: boolean | undefined;
   position?: number | undefined;
   status?: ContentStatus | undefined;
   /** Whether the content type contributes its slug to descendants' permalinks. */
@@ -46,16 +46,40 @@ export interface TreeNode {
   children: TreeNode[];
 }
 
-export interface Paginated<T> {
-  items: T[];
-  total: number;
-  limit: number;
-  offset: number;
-}
+/**
+ * The columns `publish()` copies from the draft into the projection: every column the
+ * two tables share, in the projection's order, derived from the schema so a new column
+ * cannot be forgotten on one side. `source_version` exists only on the projection and
+ * is filled from `version`.
+ */
+const PROJECTION_COLUMNS: string[] = (() => {
+  // The schema relies on `casing: 'snake_case'`, which Drizzle applies when it builds a
+  // query — `column.name` is still the TypeScript key, so the conversion is repeated here.
+  const columnNames = (table: typeof contents | typeof publishedContents) =>
+    Object.values(getTableColumns(table))
+      // `search` is a generated tsvector; Postgres refuses an explicit value for it.
+      .filter((column) => column.generated === undefined)
+      .map((column) =>
+        column.name.replace(/[A-Z]/g, (letter: string) => `_${letter.toLowerCase()}`),
+      );
+  const draft = new Set(columnNames(contents));
+  return columnNames(publishedContents).filter(
+    (name) => draft.has(name) || name === 'source_version',
+  );
+})();
+
+/** Columns that identify the row and are never rewritten on a republish. */
+const PROJECTION_IDENTITY = new Set([
+  'id',
+  'space_id',
+  'localization_id',
+  'created_at',
+  'created_by',
+]);
 
 export class ContentRepository {
   constructor(
-    private readonly db: Database,
+    private readonly db: Executor,
     private readonly registry: ContentTypeRegistry,
   ) {}
 
@@ -170,6 +194,26 @@ export class ContentRepository {
   /**
    * Every other row in a document's localization group — its translations.
    */
+  /**
+   * One document per localization group, for checking that several groups exist in a
+   * space at once — a menu's entries, say. The locale returned is whichever sorts first;
+   * a caller that needs a particular one asks `localizationSiblings` for that group.
+   */
+  async findByLocalizationIds(spaceId: string, localizationIds: string[]): Promise<ContentRow[]> {
+    if (localizationIds.length === 0) return [];
+    const rows = await this.db
+      .select()
+      .from(contents)
+      .where(and(eq(contents.spaceId, spaceId), inArray(contents.localizationId, localizationIds)))
+      .orderBy(contents.localizationId, contents.locale);
+    const seen = new Set<string>();
+    return (rows as unknown as ContentRow[]).filter((row) => {
+      if (seen.has(row.localizationId)) return false;
+      seen.add(row.localizationId);
+      return true;
+    });
+  }
+
   async localizationSiblings(
     spaceId: string,
     localizationId: string,
@@ -208,23 +252,12 @@ export class ContentRepository {
   ): Promise<Paginated<ContentRow>> {
     const table = published ? publishedContents : contents;
     const where = buildContentWhere(table, filter, this.registry);
-
-    // A window count rides along with the page, so pagination is one round trip.
-    const rows = await this.db
-      .select({ ...getTableColumns(table), total: sql<number>`count(*) over ()::int` })
-      .from(table)
-      .where(where)
-      .orderBy(buildOrderBy(sorts))
-      .limit(pagination.limit)
-      .offset(pagination.offset);
-
-    const items = rows as Array<ContentRow & { total: number }>;
-    return {
-      items: items.map(({ total: _total, ...row }) => row as ContentRow),
-      total: items[0]?.total ?? 0,
-      limit: pagination.limit,
-      offset: pagination.offset,
-    };
+    const page = await paginate(this.db, table, {
+      where,
+      orderBy: buildOrderBy(sorts),
+      pagination,
+    });
+    return page as unknown as Paginated<ContentRow>;
   }
 
   /**
@@ -281,12 +314,9 @@ export class ContentRepository {
   async create(data: ContentWriteData): Promise<ContentRow> {
     return this.db.transaction(async (tx) => {
       const id = data.id ?? crypto.randomUUID();
-      const parentPath = await this.parentPath(tx as unknown as Database, data.parentId ?? null);
+      const parentPath = await this.parentPath(tx, data.parentId ?? null);
       const path = parentPath ? `${parentPath}.${idToLabel(id)}` : idToLabel(id);
-      const parentPrefix = await this.parentPermalinkPath(
-        tx as unknown as Database,
-        data.parentId ?? null,
-      );
+      const parentPrefix = await this.parentPermalinkPath(tx, data.parentId ?? null);
       const segment = data.hasSlug ? data.slug : null;
       const permalinkPath = joinSegment(parentPrefix, segment);
       const permalink = segment === null ? null : permalinkPath;
@@ -307,7 +337,6 @@ export class ContentRepository {
           permalinkPath,
           permalinkSegment: segment,
           status: data.status ?? 'draft',
-          visibleInMenu: data.visibleInMenu ?? false,
           position: data.position ?? 0,
           fields: data.fields,
           searchText: data.searchText ?? '',
@@ -318,14 +347,14 @@ export class ContentRepository {
         .returning();
 
       if (!row) throw new ManabloxError('content.create.failed');
-      await this.snapshot(tx as unknown as Database, row, data.actorId ?? null);
+      await this.snapshot(tx, row, data.actorId ?? null);
       return row as ContentRow;
     });
   }
 
   async update(id: string, data: ContentWriteData): Promise<ContentRow> {
     return this.db.transaction(async (tx) => {
-      const current = await this.lockRow(tx as unknown as Database, id);
+      const current = await this.lockRow(tx, id);
 
       if (data.expectedVersion !== undefined && data.expectedVersion !== current.version) {
         throw ManabloxError.conflict('content.version.conflict', {
@@ -339,10 +368,10 @@ export class ContentRepository {
       const segmentChanged = segment !== current.permalinkSegment;
 
       if (parentChanged) {
-        await this.assertNotOwnDescendant(tx as unknown as Database, id, data.parentId ?? null);
+        await this.assertNotOwnDescendant(tx, id, data.parentId ?? null);
       }
 
-      const parentPath = await this.parentPath(tx as unknown as Database, data.parentId ?? null);
+      const parentPath = await this.parentPath(tx, data.parentId ?? null);
       const newPath = parentPath ? `${parentPath}.${idToLabel(id)}` : idToLabel(id);
 
       const [row] = await tx
@@ -357,7 +386,6 @@ export class ContentRepository {
           permalinkSegment: segment,
           fields: data.fields,
           searchText: data.searchText ?? '',
-          visibleInMenu: data.visibleInMenu ?? current.visibleInMenu,
           position: data.position ?? current.position,
           version: current.version + 1,
           updatedAt: new Date(),
@@ -369,15 +397,15 @@ export class ContentRepository {
       if (!row) throw ManabloxError.notFound('content.notFound', { id });
 
       if (parentChanged) {
-        await this.moveSubtree(tx as unknown as Database, id, current.path, newPath);
+        await this.moveSubtree(tx, id, current.path, newPath);
       }
 
       if (parentChanged || segmentChanged) {
-        await this.recomputePermalinks(tx as unknown as Database, contents, id);
+        await this.recomputePermalinks(tx, contents, id);
       }
 
-      const fresh = (await this.findRow(tx as unknown as Database, id)) ?? (row as ContentRow);
-      await this.snapshot(tx as unknown as Database, fresh, data.actorId ?? null);
+      const fresh = (await this.findRow(tx, id)) ?? (row as ContentRow);
+      await this.snapshot(tx, fresh, data.actorId ?? null);
       return fresh;
     });
   }
@@ -400,7 +428,7 @@ export class ContentRepository {
    */
   async move(id: string, parentId: string | null, position: number): Promise<ContentRow> {
     return this.db.transaction(async (tx) => {
-      const db = tx as unknown as Database;
+      const db = tx;
       const current = await this.findRow(db, id);
       if (!current) throw ManabloxError.notFound('content.notFound', { id });
 
@@ -433,9 +461,7 @@ export class ContentRepository {
         .set({ parentId, path: newPath, updatedAt: new Date() })
         .where(eq(contents.id, id));
 
-      for (const [at, sibling] of order.entries()) {
-        await tx.update(contents).set({ position: at }).where(eq(contents.id, sibling));
-      }
+      await this.renumber(db, order);
 
       if (parentChanged) {
         await this.moveSubtree(db, id, current.path, newPath);
@@ -455,9 +481,10 @@ export class ContentRepository {
             ),
           )
           .orderBy(sql`${contents.position} asc, ${contents.title} asc`)) as { id: string }[];
-        for (const [at, sibling] of former.entries()) {
-          await tx.update(contents).set({ position: at }).where(eq(contents.id, sibling.id));
-        }
+        await this.renumber(
+          db,
+          former.map((row) => row.id),
+        );
       }
 
       const fresh = await this.findRow(db, id);
@@ -466,8 +493,32 @@ export class ContentRepository {
     });
   }
 
+  /**
+   * Writes `position = index` for a whole sibling list in one statement: the ids and
+   * their new positions travel as two arrays and are joined by `unnest`, so a drag in a
+   * forty-child section costs one round trip rather than forty. Rows already in place
+   * are left untouched, so their `updated_at` and version do not move either.
+   */
+  private async renumber(db: Executor, ids: string[]): Promise<void> {
+    if (ids.length === 0) return;
+    const idList = sql.join(
+      ids.map((id) => sql`${id}::uuid`),
+      sql`, `,
+    );
+    const positions = sql.join(
+      ids.map((_, index) => sql`${index}::int`),
+      sql`, `,
+    );
+    await db.execute(sql`
+      update contents
+      set position = v.pos
+      from (select unnest(array[${idList}]) as id, unnest(array[${positions}]) as pos) v
+      where contents.id = v.id and contents.position is distinct from v.pos
+    `);
+  }
+
   private async moveSubtree(
-    db: Database,
+    db: Executor,
     id: string,
     oldPath: string,
     newPath: string,
@@ -486,7 +537,7 @@ export class ContentRepository {
    * `concat_ws` drops NULL segments so a type without a slug is transparent in the path.
    */
   private async recomputePermalinks(
-    db: Database,
+    db: Executor,
     table: typeof contents | typeof publishedContents,
     rootId: string,
   ): Promise<void> {
@@ -526,7 +577,7 @@ export class ContentRepository {
   /** Deletes a node and its whole subtree, in both the draft and published tables. */
   async delete(id: string): Promise<number> {
     return this.db.transaction(async (tx) => {
-      const current = await this.findRow(tx as unknown as Database, id);
+      const current = await this.findRow(tx, id);
       if (!current) throw ManabloxError.notFound('content.notFound', { id });
 
       await tx.execute(sql`
@@ -553,50 +604,54 @@ export class ContentRepository {
    */
   async publish(id: string, actorId: string | null = null): Promise<ContentRow> {
     return this.db.transaction(async (tx) => {
-      const row = await this.findRow(tx as unknown as Database, id);
+      const row = await this.findRow(tx, id);
       if (!row) throw ManabloxError.notFound('content.notFound', { id });
 
+      // What the projection held for this node before, if anything. Descendants derive
+      // their permalinks from the node's `permalink_path`, so if that is unchanged by
+      // this publish they cannot have gone stale and the subtree walk below is skipped.
+      const previous = (
+        await tx
+          .select({ permalinkPath: publishedContents.permalinkPath })
+          .from(publishedContents)
+          .where(eq(publishedContents.id, id))
+          .limit(1)
+      )[0];
+
       const publishedAt = new Date();
       // `db.execute` binds parameters through postgres.js's unsafe path, which has no
       // Date serialiser — pass an ISO string and let Postgres cast it.
       const publishedAtIso = publishedAt.toISOString();
 
+      // What the projection gets that the draft row does not say: it is published, now,
+      // by this actor, from this draft version.
+      const overrides: Record<string, SQL> = {
+        status: sql`'published'`,
+        source_version: sql`version`,
+        updated_at: sql`now()`,
+        updated_by: sql`${actorId}::uuid`,
+        published_at: sql`${publishedAtIso}::timestamptz`,
+      };
+      const columns = PROJECTION_COLUMNS.map((name) => sql.identifier(name));
+      const values = PROJECTION_COLUMNS.map((name) => overrides[name] ?? sql.identifier(name));
+      const updates = PROJECTION_COLUMNS.filter((name) => !PROJECTION_IDENTITY.has(name)).map(
+        (name) => sql`${sql.identifier(name)} = excluded.${sql.identifier(name)}`,
+      );
+
       await tx.execute(sql`
-        insert into published_contents (
-          id, space_id, type_id, locale, localization_id, parent_id, title, slug, path,
-          permalink, permalink_path, permalink_segment, status, visible_in_menu, position, fields,
-          search_text, version, source_version, created_at, updated_at, created_by,
-          updated_by, published_at
-        )
-        select id, space_id, type_id, locale, localization_id, parent_id, title, slug, path,
-               permalink, permalink_path, permalink_segment, 'published', visible_in_menu, position, fields,
-               search_text, version, version, created_at, now(), created_by,
-               ${actorId}::uuid, ${publishedAtIso}::timestamptz
+        insert into published_contents (${sql.join(columns, sql`, `)})
+        select ${sql.join(values, sql`, `)}
         from contents where id = ${id}::uuid
-        on conflict (id) do update set
-          type_id = excluded.type_id,
-          locale = excluded.locale,
-          parent_id = excluded.parent_id,
-          title = excluded.title,
-          slug = excluded.slug,
-          path = excluded.path,
-          permalink = excluded.permalink,
-          permalink_path = excluded.permalink_path,
-          permalink_segment = excluded.permalink_segment,
-          status = 'published',
-          visible_in_menu = excluded.visible_in_menu,
-          position = excluded.position,
-          fields = excluded.fields,
-          search_text = excluded.search_text,
-          version = excluded.version,
-          source_version = excluded.version,
-          updated_at = now(),
-          updated_by = excluded.updated_by,
-          published_at = excluded.published_at
+        on conflict (id) do update set ${sql.join(updates, sql`, `)}
       `);
 
-      // Descendants already live in the projection may sit under a stale permalink.
-      await this.recomputePermalinks(tx as unknown as Database, publishedContents, id);
+      // Descendants already in the projection may sit under a stale permalink: the node
+      // moved or was re-slugged since they were published, or it was never projected and
+      // they were published beneath its draft path. A republish that leaves the path as
+      // it was cannot have affected them.
+      if (previous?.permalinkPath !== row.permalinkPath) {
+        await this.recomputePermalinks(tx, publishedContents, id);
+      }
 
       const [updated] = await tx
         .update(contents)
@@ -645,19 +700,17 @@ export class ContentRepository {
     return rows;
   }
 
-  async versionSnapshot(
-    contentId: string,
-    version: number,
-  ): Promise<Record<string, unknown> | null> {
+  /** The row exactly as it was at that version — `snapshot()` stores the whole row. */
+  async versionSnapshot(contentId: string, version: number): Promise<ContentRow | null> {
     const rows = await this.db
       .select({ snapshot: contentVersions.snapshot })
       .from(contentVersions)
       .where(and(eq(contentVersions.contentId, contentId), eq(contentVersions.version, version)))
       .limit(1);
-    return rows[0]?.snapshot ?? null;
+    return (rows[0]?.snapshot as ContentRow | undefined) ?? null;
   }
 
-  private async snapshot(db: Database, row: ContentRow, actorId: string | null): Promise<void> {
+  private async snapshot(db: Executor, row: ContentRow, actorId: string | null): Promise<void> {
     await db
       .insert(contentVersions)
       .values({
@@ -673,19 +726,19 @@ export class ContentRepository {
   // Internals
   // -------------------------------------------------------------------------
 
-  private async findRow(db: Database, id: string): Promise<ContentRow | null> {
+  private async findRow(db: Executor, id: string): Promise<ContentRow | null> {
     const rows = await db.select().from(contents).where(eq(contents.id, id)).limit(1);
     return (rows[0] as ContentRow | undefined) ?? null;
   }
 
-  private async lockRow(db: Database, id: string): Promise<ContentRow> {
+  private async lockRow(db: Executor, id: string): Promise<ContentRow> {
     const rows = await db.select().from(contents).where(eq(contents.id, id)).limit(1).for('update');
     const row = rows[0] as ContentRow | undefined;
     if (!row) throw ManabloxError.notFound('content.notFound', { id });
     return row;
   }
 
-  private async parentPath(db: Database, parentId: string | null): Promise<string | null> {
+  private async parentPath(db: Executor, parentId: string | null): Promise<string | null> {
     if (!parentId) return null;
     const rows = await db
       .select({ path: contents.path })
@@ -697,7 +750,7 @@ export class ContentRepository {
     return path;
   }
 
-  private async parentPermalinkPath(db: Database, parentId: string | null): Promise<string> {
+  private async parentPermalinkPath(db: Executor, parentId: string | null): Promise<string> {
     if (!parentId) return '';
     const rows = await db
       .select({ permalinkPath: contents.permalinkPath })
@@ -709,7 +762,7 @@ export class ContentRepository {
 
   /** Guards against making a node its own ancestor, which would orphan the subtree. */
   private async assertNotOwnDescendant(
-    db: Database,
+    db: Executor,
     id: string,
     parentId: string | null,
   ): Promise<void> {

package/src/repositories/index.ts

@@ -4,8 +4,12 @@ import { AssetRepository } from './asset.js';
 import { AssetUsageRepository } from './asset-usage.js';
 import { ContentRepository } from './content.js';
 import { ContentTypeRepository } from './content-type.js';
+import { MenuRepository } from './menu.js';
+import { RoleRepository } from './role.js';
 import { SpaceRepository } from './space.js';
 import { UserRepository } from './user.js';
+import { WebhookRepository } from './webhook.js';
+import { WorkflowRepository } from './workflow.js';
 
 export interface Repositories {
   content: ContentRepository;
@@ -14,6 +18,10 @@ export interface Repositories {
   assets: AssetRepository;
   assetUsages: AssetUsageRepository;
   users: UserRepository;
+  menus: MenuRepository;
+  roles: RoleRepository;
+  workflows: WorkflowRepository;
+  webhooks: WebhookRepository;
 }
 
 export function createRepositories(db: Database, registry: ContentTypeRegistry): Repositories {
@@ -24,5 +32,9 @@ export function createRepositories(db: Database, registry: ContentTypeRegistry):
     assets: new AssetRepository(db),
     assetUsages: new AssetUsageRepository(db),
     users: new UserRepository(db),
+    menus: new MenuRepository(db),
+    roles: new RoleRepository(db),
+    workflows: new WorkflowRepository(db),
+    webhooks: new WebhookRepository(db),
   };
 }