@manablox/db 0.2.0 → 0.3.0

package/src/repositories/index.ts

@@ -1,40 +0,0 @@
-import type { ContentTypeRegistry } from '@manablox/core';
-import type { Database } from '../client.js';
-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;
-  contentTypes: ContentTypeRepository;
-  spaces: SpaceRepository;
-  assets: AssetRepository;
-  assetUsages: AssetUsageRepository;
-  users: UserRepository;
-  menus: MenuRepository;
-  roles: RoleRepository;
-  workflows: WorkflowRepository;
-  webhooks: WebhookRepository;
-}
-
-export function createRepositories(db: Database, registry: ContentTypeRegistry): Repositories {
-  return {
-    content: new ContentRepository(db, registry),
-    contentTypes: new ContentTypeRepository(db),
-    spaces: new SpaceRepository(db),
-    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),
-  };
-}

package/src/repositories/menu.ts

@@ -1,235 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { type Loose, ManabloxError } from '@manablox/core';
-import { and, asc, eq, inArray } from 'drizzle-orm';
-import type { Database } from '../client.js';
-import {
-  type ContentRow,
-  contents,
-  type MenuItemRow,
-  type MenuRow,
-  menuItems,
-  menus,
-  publishedContents,
-} from '../schema/index.js';
-
-export interface MenuWriteData {
-  id?: string | undefined;
-  spaceId: string;
-  name: string;
-  machineName: string;
-  description?: string | null | undefined;
-}
-
-/**
- * One entry as the admin hands over the whole menu: a content entry names a
- * `localizationId`, a link entry a `url`; either may carry a label. `id` is kept when
- * given, so an unchanged entry keeps its identity across saves.
- */
-export interface MenuItemInput {
-  id?: string | undefined;
-  localizationId?: string | null | undefined;
-  label?: string | null | undefined;
-  url?: string | null | undefined;
-  children?: MenuItemInput[] | undefined;
-}
-
-export interface MenuItemNode {
-  item: MenuItemRow;
-  children: MenuItemNode[];
-}
-
-/** An entry with its document looked up for one locale; `content` is null for a link. */
-export interface ResolvedMenuItem {
-  id: string;
-  label: string | null;
-  url: string | null;
-  localizationId: string | null;
-  content: ContentRow | null;
-  children: ResolvedMenuItem[];
-}
-
-export class MenuRepository {
-  constructor(private readonly db: Database) {}
-
-  async listBySpace(spaceId: string): Promise<MenuRow[]> {
-    return this.db.select().from(menus).where(eq(menus.spaceId, spaceId)).orderBy(menus.name);
-  }
-
-  async findById(id: string): Promise<MenuRow | null> {
-    const rows = await this.db.select().from(menus).where(eq(menus.id, id)).limit(1);
-    return rows[0] ?? null;
-  }
-
-  async findByMachineName(spaceId: string, machineName: string): Promise<MenuRow | null> {
-    const rows = await this.db
-      .select()
-      .from(menus)
-      .where(and(eq(menus.spaceId, spaceId), eq(menus.machineName, machineName)))
-      .limit(1);
-    return rows[0] ?? null;
-  }
-
-  async create(data: MenuWriteData): Promise<MenuRow> {
-    const [row] = await this.db
-      .insert(menus)
-      .values({
-        ...(data.id ? { id: data.id } : {}),
-        spaceId: data.spaceId,
-        name: data.name,
-        machineName: data.machineName,
-        description: data.description ?? null,
-      })
-      .returning();
-    if (!row) throw new ManabloxError('menu.create.failed');
-    return row;
-  }
-
-  async update(id: string, data: Loose<Omit<MenuWriteData, 'spaceId'>>): Promise<MenuRow> {
-    const [row] = await this.db
-      .update(menus)
-      .set({
-        ...(data.name !== undefined ? { name: data.name } : {}),
-        ...(data.machineName !== undefined ? { machineName: data.machineName } : {}),
-        ...(data.description !== undefined ? { description: data.description } : {}),
-        updatedAt: new Date(),
-      })
-      .where(eq(menus.id, id))
-      .returning();
-    if (!row) throw ManabloxError.notFound('menu.notFound', { id });
-    return row;
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.db.delete(menus).where(eq(menus.id, id));
-  }
-
-  /** Every entry of a menu, flat, in tree order within each level. */
-  async items(menuId: string): Promise<MenuItemRow[]> {
-    return this.db
-      .select()
-      .from(menuItems)
-      .where(eq(menuItems.menuId, menuId))
-      .orderBy(asc(menuItems.position), asc(menuItems.id));
-  }
-
-  async tree(menuId: string): Promise<MenuItemNode[]> {
-    return buildTree(await this.items(menuId));
-  }
-
-  /**
-   * Replaces the whole entry tree in one transaction.
-   *
-   * A menu is edited as one document and saved as one, so this is simpler and safer than
-   * a per-entry API whose partial failures would leave a half-reordered menu behind.
-   */
-  async setItems(menuId: string, tree: MenuItemInput[]): Promise<MenuItemNode[]> {
-    const rows: (typeof menuItems.$inferInsert)[] = [];
-    const flatten = (nodes: MenuItemInput[], parentId: string | null) => {
-      nodes.forEach((node, position) => {
-        const id = node.id ?? randomUUID();
-        rows.push({
-          id,
-          menuId,
-          parentId,
-          position,
-          localizationId: node.localizationId ?? null,
-          label: node.label ?? null,
-          url: node.url ?? null,
-        });
-        flatten(node.children ?? [], id);
-      });
-    };
-    flatten(tree, null);
-
-    return this.db.transaction(async (tx) => {
-      await tx.delete(menuItems).where(eq(menuItems.menuId, menuId));
-      if (rows.length) await tx.insert(menuItems).values(rows);
-      await tx.update(menus).set({ updatedAt: new Date() }).where(eq(menus.id, menuId));
-      return buildTree(rows.map((row) => ({ ...row, position: row.position ?? 0 }) as MenuItemRow));
-    });
-  }
-
-  /** Menus that carry the document, for the editor's "used in" hint. */
-  async menusReferencing(spaceId: string, localizationId: string): Promise<MenuRow[]> {
-    return this.db
-      .selectDistinct({
-        id: menus.id,
-        spaceId: menus.spaceId,
-        name: menus.name,
-        machineName: menus.machineName,
-        description: menus.description,
-        createdAt: menus.createdAt,
-        updatedAt: menus.updatedAt,
-      })
-      .from(menuItems)
-      .innerJoin(menus, eq(menuItems.menuId, menus.id))
-      .where(and(eq(menus.spaceId, spaceId), eq(menuItems.localizationId, localizationId)))
-      .orderBy(menus.name);
-  }
-
-  /** Drops every entry pointing at a document, in every menu; sub-entries cascade. */
-  async removeContent(localizationId: string): Promise<number> {
-    const removed = await this.db
-      .delete(menuItems)
-      .where(eq(menuItems.localizationId, localizationId))
-      .returning({ id: menuItems.id });
-    return removed.length;
-  }
-
-  /**
-   * The tree with each content entry's document for one locale. A content entry whose
-   * document has no row in that locale — or, on the published table, no published one —
-   * comes back with `content: null`; the caller decides whether to show or drop it.
-   */
-  async resolve(menu: MenuRow, locale: string, published = false): Promise<ResolvedMenuItem[]> {
-    const items = await this.items(menu.id);
-    const localizationIds = [
-      ...new Set(items.flatMap((item) => (item.localizationId ? [item.localizationId] : []))),
-    ];
-
-    const table = published ? publishedContents : contents;
-    const rows = localizationIds.length
-      ? await this.db
-          .select()
-          .from(table)
-          .where(
-            and(
-              eq(table.spaceId, menu.spaceId),
-              eq(table.locale, locale),
-              inArray(table.localizationId, localizationIds),
-            ),
-          )
-      : [];
-    const byLocalization = new Map(rows.map((row) => [row.localizationId, row]));
-
-    const toResolved = (node: MenuItemNode): ResolvedMenuItem => ({
-      id: node.item.id,
-      label: node.item.label,
-      url: node.item.url,
-      localizationId: node.item.localizationId,
-      content: node.item.localizationId
-        ? (byLocalization.get(node.item.localizationId) ?? null)
-        : null,
-      children: node.children.map(toResolved),
-    });
-    return buildTree(items).map(toResolved);
-  }
-}
-
-function buildTree(rows: MenuItemRow[]): MenuItemNode[] {
-  const nodes = new Map<string, MenuItemNode>();
-  for (const row of rows) nodes.set(row.id, { item: row, children: [] });
-
-  const roots: MenuItemNode[] = [];
-  for (const node of nodes.values()) {
-    const parent = node.item.parentId ? nodes.get(node.item.parentId) : undefined;
-    (parent ? parent.children : roots).push(node);
-  }
-  const byPosition = (a: MenuItemNode, b: MenuItemNode) => a.item.position - b.item.position;
-  const sort = (list: MenuItemNode[]) => {
-    list.sort(byPosition);
-    for (const node of list) sort(node.children);
-  };
-  sort(roots);
-  return roots;
-}

package/src/repositories/role.ts

@@ -1,85 +0,0 @@
-import { ManabloxError } from '@manablox/core';
-import { and, eq, sql } from 'drizzle-orm';
-import type { Database } from '../client.js';
-import { memberships, type RoleRow, roles } from '../schema/index.js';
-
-export interface RoleWriteData {
-  name: string;
-  machineName: string;
-  description?: string | null;
-  permissions: string[];
-}
-
-export class RoleRepository {
-  constructor(private readonly db: Database) {}
-
-  async listBySpace(spaceId: string): Promise<RoleRow[]> {
-    return this.db.select().from(roles).where(eq(roles.spaceId, spaceId)).orderBy(roles.name);
-  }
-
-  async findById(id: string): Promise<RoleRow | null> {
-    const rows = await this.db.select().from(roles).where(eq(roles.id, id)).limit(1);
-    return rows[0] ?? null;
-  }
-
-  async findByMachineName(spaceId: string, machineName: string): Promise<RoleRow | null> {
-    const rows = await this.db
-      .select()
-      .from(roles)
-      .where(and(eq(roles.spaceId, spaceId), eq(roles.machineName, machineName)))
-      .limit(1);
-    return rows[0] ?? null;
-  }
-
-  async create(spaceId: string, data: RoleWriteData): Promise<RoleRow> {
-    const [row] = await this.db
-      .insert(roles)
-      .values({ spaceId, ...data })
-      .returning();
-    if (!row) throw new ManabloxError('role.create.failed');
-    return row;
-  }
-
-  async update(id: string, data: Partial<RoleWriteData>): Promise<RoleRow> {
-    const [row] = await this.db
-      .update(roles)
-      .set({ ...data, updatedAt: new Date() })
-      .where(eq(roles.id, id))
-      .returning();
-    if (!row) throw ManabloxError.notFound('role.notFound', { id });
-    return row;
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.db.delete(roles).where(eq(roles.id, id));
-  }
-
-  /** How many members of the role's space hold it, by name. */
-  async countMembers(spaceId: string, machineName: string): Promise<number> {
-    const rows = await this.db
-      .select({ count: sql<number>`count(*)::int` })
-      .from(memberships)
-      .where(and(eq(memberships.spaceId, spaceId), eq(memberships.role, machineName)));
-    return rows[0]?.count ?? 0;
-  }
-
-  /**
-   * Drops every grant narrowed to a content type from every role, once the type is
-   * gone. Grants are a JSON array, so this is one statement across the roles that carry
-   * such a grant rather than a read-modify-write per role.
-   */
-  async pruneContentType(typeId: string): Promise<void> {
-    const suffix = `:${typeId}`;
-    await this.db
-      .update(roles)
-      .set({
-        permissions: sql`(
-          select coalesce(jsonb_agg(value), '[]'::jsonb)
-          from jsonb_array_elements_text(${roles.permissions}) as value
-          where value not like ${`%${suffix}`}
-        )`,
-        updatedAt: new Date(),
-      })
-      .where(sql`${roles.permissions}::text like ${`%${suffix}%`}`);
-  }
-}

package/src/repositories/space.ts

@@ -1,83 +0,0 @@
-import { type Loose, ManabloxError } from '@manablox/core';
-import { eq, inArray } from 'drizzle-orm';
-import type { Database } from '../client.js';
-import { type SpaceRow, spaces } from '../schema/index.js';
-
-export interface SpaceWriteData {
-  id?: string | undefined;
-  name: string;
-  machineName: string;
-  description?: string | null | undefined;
-  url: string;
-  defaultLocale?: string | undefined;
-  locales?: string[] | undefined;
-  settings?: Record<string, unknown> | undefined;
-}
-
-export class SpaceRepository {
-  constructor(private readonly db: Database) {}
-
-  async all(): Promise<SpaceRow[]> {
-    return this.db.select().from(spaces).orderBy(spaces.name);
-  }
-
-  async findManyByIds(ids: string[]): Promise<SpaceRow[]> {
-    if (ids.length === 0) return [];
-    return this.db.select().from(spaces).where(inArray(spaces.id, ids)).orderBy(spaces.name);
-  }
-
-  async findById(id: string): Promise<SpaceRow | null> {
-    const rows = await this.db.select().from(spaces).where(eq(spaces.id, id)).limit(1);
-    return rows[0] ?? null;
-  }
-
-  async findByMachineName(machineName: string): Promise<SpaceRow | null> {
-    const rows = await this.db
-      .select()
-      .from(spaces)
-      .where(eq(spaces.machineName, machineName))
-      .limit(1);
-    return rows[0] ?? null;
-  }
-
-  async create(data: SpaceWriteData): Promise<SpaceRow> {
-    const [row] = await this.db
-      .insert(spaces)
-      .values({
-        ...(data.id ? { id: data.id } : {}),
-        name: data.name,
-        machineName: data.machineName,
-        description: data.description ?? null,
-        url: data.url,
-        defaultLocale: data.defaultLocale ?? 'en',
-        locales: data.locales ?? [data.defaultLocale ?? 'en'],
-        settings: data.settings ?? {},
-      })
-      .returning();
-    if (!row) throw new ManabloxError('space.create.failed');
-    return row;
-  }
-
-  async update(id: string, data: Loose<SpaceWriteData>): Promise<SpaceRow> {
-    const [row] = await this.db
-      .update(spaces)
-      .set({
-        ...(data.name !== undefined ? { name: data.name } : {}),
-        ...(data.machineName !== undefined ? { machineName: data.machineName } : {}),
-        ...(data.description !== undefined ? { description: data.description } : {}),
-        ...(data.url !== undefined ? { url: data.url } : {}),
-        ...(data.defaultLocale !== undefined ? { defaultLocale: data.defaultLocale } : {}),
-        ...(data.locales !== undefined ? { locales: data.locales } : {}),
-        ...(data.settings !== undefined ? { settings: data.settings } : {}),
-        updatedAt: new Date(),
-      })
-      .where(eq(spaces.id, id))
-      .returning();
-    if (!row) throw ManabloxError.notFound('space.notFound', { id });
-    return row;
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.db.delete(spaces).where(eq(spaces.id, id));
-  }
-}