@manablox/db 0.1.0 → 0.2.0

package/src/repositories/menu.ts

@@ -0,0 +1,235 @@
+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

@@ -0,0 +1,85 @@
+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,7 +1,7 @@
 import { type Loose, ManabloxError } from '@manablox/core';
-import { eq } from 'drizzle-orm';
+import { eq, inArray } from 'drizzle-orm';
 import type { Database } from '../client.js';
-import { type SpaceRow, spaces } from '../schema.js';
+import { type SpaceRow, spaces } from '../schema/index.js';
 
 export interface SpaceWriteData {
   id?: string | undefined;
@@ -21,6 +21,11 @@ export class SpaceRepository {
     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;

package/src/repositories/user.ts

@@ -1,10 +1,44 @@
 import { ManabloxError } from '@manablox/core';
 import { and, desc, eq, inArray, sql } from 'drizzle-orm';
 import type { Database } from '../client.js';
-import { type MembershipRow, memberships, type UserRow, users } from '../schema.js';
-import type { Paginated, Pagination } from './content.js';
+import { type Paginated, paginate } from '../pagination.js';
+import type { Pagination } from '../query.js';
+import {
+  accounts,
+  type MembershipRow,
+  memberships,
+  roles,
+  type SpaceRow,
+  sessions,
+  spaces,
+  type UserRow,
+  users,
+} from '../schema/index.js';
 
-export type SpaceRole = 'owner' | 'admin' | 'editor' | 'author' | 'viewer';
+/** The name of a role in a space: one of the built-in five, or a row in `roles`. */
+export type SpaceRole = string;
+
+/** What it takes to create an account that can sign in with a password. */
+export interface UserCreateData {
+  name: string;
+  email: string;
+  role: string;
+  /** Already hashed; the repository never sees a plaintext password. */
+  passwordHash: string;
+}
+
+export interface UserUpdateData {
+  name?: string;
+  email?: string;
+}
+
+/**
+ * How better-auth 1.7 identifies an email + password credential: sign-in looks for an
+ * account with this provider *and* this issuer, so a row missing either is invisible to
+ * it and the account can never sign in.
+ */
+const CREDENTIAL_PROVIDER = 'credential';
+const CREDENTIAL_ISSUER = 'local:credential';
 
 export class UserRepository {
   constructor(private readonly db: Database) {}
@@ -29,23 +63,23 @@ export class UserRepository {
       ? sql`${users.email} ilike ${`%${search}%`} or ${users.name} ilike ${`%${search}%`}`
       : undefined;
 
-    const [items, counted] = await Promise.all([
-      this.db
-        .select()
-        .from(users)
-        .where(where)
-        .orderBy(desc(users.createdAt))
-        .limit(pagination.limit)
-        .offset(pagination.offset),
-      this.db.select({ count: sql<number>`count(*)::int` }).from(users).where(where),
-    ]);
-
-    return {
-      items,
-      total: counted[0]?.count ?? 0,
-      limit: pagination.limit,
-      offset: pagination.offset,
-    };
+    return paginate(this.db, users, { where, orderBy: desc(users.createdAt), pagination });
+  }
+
+  /**
+   * Users who are not members of a space, matching a search, newest first: the
+   * add-member picker's candidates, decided in SQL rather than by loading a page of
+   * users and filtering it here.
+   */
+  async candidates(spaceId: string, search: string | undefined, limit: number): Promise<UserRow[]> {
+    const notMember = sql`not exists (select 1 from ${memberships} where ${memberships.userId} = ${users.id} and ${memberships.spaceId} = ${spaceId})`;
+    const where = search
+      ? and(
+          notMember,
+          sql`(${users.email} ilike ${`%${search}%`} or ${users.name} ilike ${`%${search}%`})`,
+        )
+      : notMember;
+    return this.db.select().from(users).where(where).orderBy(desc(users.createdAt)).limit(limit);
   }
 
   async count(): Promise<number> {
@@ -53,6 +87,93 @@ export class UserRepository {
     return rows[0]?.count ?? 0;
   }
 
+  /**
+   * Inserts the user and its password credential together, so a failure on the second
+   * row cannot leave an account nobody can sign in to. The account row is shaped the way
+   * better-auth writes it on sign-up, so a sign-in later finds it as its own.
+   */
+  async create(data: UserCreateData): Promise<UserRow> {
+    return this.db.transaction(async (tx) => {
+      const [user] = await tx
+        .insert(users)
+        .values({ name: data.name, email: data.email, role: data.role })
+        .returning();
+      if (!user) throw new ManabloxError('user.create.failed');
+      await tx.insert(accounts).values({
+        userId: user.id,
+        accountId: user.id,
+        providerId: CREDENTIAL_PROVIDER,
+        issuer: CREDENTIAL_ISSUER,
+        password: data.passwordHash,
+      });
+      return user;
+    });
+  }
+
+  async update(id: string, data: UserUpdateData): Promise<UserRow> {
+    const [row] = await this.db
+      .update(users)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(users.id, id))
+      .returning();
+    if (!row) throw ManabloxError.notFound('user.notFound', { id });
+    return row;
+  }
+
+  async delete(id: string): Promise<void> {
+    // Sessions, accounts, api keys and memberships cascade in the schema.
+    await this.db.delete(users).where(eq(users.id, id));
+  }
+
+  async setBanned(id: string, banned: boolean, reason: string | null): Promise<UserRow> {
+    const [row] = await this.db
+      .update(users)
+      .set({ banned, banReason: banned ? reason : null, updatedAt: new Date() })
+      .where(eq(users.id, id))
+      .returning();
+    if (!row) throw ManabloxError.notFound('user.notFound', { id });
+    return row;
+  }
+
+  /**
+   * Replaces the password credential, creating it for an account that only ever signed
+   * in through another provider.
+   */
+  async setPasswordHash(userId: string, passwordHash: string): Promise<void> {
+    const updated = await this.db
+      .update(accounts)
+      .set({ password: passwordHash, updatedAt: new Date() })
+      .where(
+        and(
+          eq(accounts.userId, userId),
+          eq(accounts.providerId, CREDENTIAL_PROVIDER),
+          eq(accounts.issuer, CREDENTIAL_ISSUER),
+        ),
+      )
+      .returning({ id: accounts.id });
+    if (updated.length) return;
+    await this.db.insert(accounts).values({
+      userId,
+      accountId: userId,
+      providerId: CREDENTIAL_PROVIDER,
+      issuer: CREDENTIAL_ISSUER,
+      password: passwordHash,
+    });
+  }
+
+  /** Signs the user out everywhere. */
+  async revokeSessions(userId: string): Promise<void> {
+    await this.db.delete(sessions).where(eq(sessions.userId, userId));
+  }
+
+  async countByRole(role: string): Promise<number> {
+    const rows = await this.db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(users)
+      .where(eq(users.role, role));
+    return rows[0]?.count ?? 0;
+  }
+
   async setRole(id: string, role: string): Promise<UserRow> {
     const [row] = await this.db
       .update(users)
@@ -71,36 +192,61 @@ export class UserRepository {
    * Read on every authenticated request rather than trusting the role embedded in the
    * session: better-auth caches the session payload (five minutes by default), so a
    * promotion or demotion would otherwise not take effect until that cache expired.
+   *
+   * A membership naming a custom role joins that role's grants; one naming a built-in
+   * role has none here, and the auth package answers those from its own table.
    */
-  async principal(
-    userId: string,
-  ): Promise<{ role: string; banned: boolean; spaces: Record<string, SpaceRole> } | null> {
+  async principal(userId: string): Promise<{
+    role: string;
+    banned: boolean;
+    spaces: Record<string, SpaceRole>;
+    permissions: Record<string, string[]>;
+  } | null> {
     const rows = await this.db
       .select({
         role: users.role,
         banned: users.banned,
         spaceId: memberships.spaceId,
         spaceRole: memberships.role,
+        grants: roles.permissions,
       })
       .from(users)
       .leftJoin(memberships, eq(memberships.userId, users.id))
+      .leftJoin(
+        roles,
+        and(eq(roles.spaceId, memberships.spaceId), eq(roles.machineName, memberships.role)),
+      )
       .where(eq(users.id, userId));
 
     const first = rows[0];
     if (!first) return null;
 
     const spaces: Record<string, SpaceRole> = {};
+    const permissions: Record<string, string[]> = {};
     for (const row of rows) {
-      if (row.spaceId && row.spaceRole) spaces[row.spaceId] = row.spaceRole;
+      if (!row.spaceId || !row.spaceRole) continue;
+      spaces[row.spaceId] = row.spaceRole;
+      if (row.grants) permissions[row.spaceId] = row.grants;
     }
 
-    return { role: first.role, banned: first.banned, spaces };
+    return { role: first.role, banned: first.banned, spaces, permissions };
   }
 
   async memberships(userId: string): Promise<MembershipRow[]> {
     return this.db.select().from(memberships).where(eq(memberships.userId, userId));
   }
 
+  /** The user's memberships with the space each one is in, for a per-user view. */
+  async membershipsWithSpaces(userId: string): Promise<Array<MembershipRow & { space: SpaceRow }>> {
+    const rows = await this.db
+      .select({ membership: memberships, space: spaces })
+      .from(memberships)
+      .innerJoin(spaces, eq(spaces.id, memberships.spaceId))
+      .where(eq(memberships.userId, userId))
+      .orderBy(spaces.name);
+    return rows.map((row) => ({ ...row.membership, space: row.space }));
+  }
+
   async membersOf(spaceId: string): Promise<Array<MembershipRow & { user: UserRow }>> {
     const rows = await this.db
       .select({ membership: memberships, user: users })

package/src/repositories/webhook.ts

@@ -0,0 +1,46 @@
+import { and, eq } from 'drizzle-orm';
+import type { Database } from '../client.js';
+import { webhookDeliveries, webhooks } from '../schema/index.js';
+
+export type WebhookRow = typeof webhooks.$inferSelect;
+export type WebhookDeliveryRow = typeof webhookDeliveries.$inferSelect;
+
+export interface WebhookDeliveryData {
+  webhookId: string;
+  event: string;
+  payload: Record<string, unknown>;
+  status: number | null;
+  error: string | null;
+}
+
+/** The webhooks of a space and the log of what was sent to them. */
+export class WebhookRepository {
+  constructor(private readonly db: Database) {}
+
+  async findById(id: string): Promise<WebhookRow | null> {
+    const rows = await this.db.select().from(webhooks).where(eq(webhooks.id, id)).limit(1);
+    return rows[0] ?? null;
+  }
+
+  /** The switched-on webhooks of a space, for fanning an event out. */
+  async findEnabled(spaceId: string): Promise<WebhookRow[]> {
+    return this.db
+      .select()
+      .from(webhooks)
+      .where(and(eq(webhooks.spaceId, spaceId), eq(webhooks.enabled, true)));
+  }
+
+  async recordDelivery(data: WebhookDeliveryData): Promise<WebhookDeliveryRow> {
+    const [row] = await this.db.insert(webhookDeliveries).values(data).returning();
+    return row as WebhookDeliveryRow;
+  }
+
+  async deliveries(webhookId: string, limit = 50): Promise<WebhookDeliveryRow[]> {
+    return this.db
+      .select()
+      .from(webhookDeliveries)
+      .where(eq(webhookDeliveries.webhookId, webhookId))
+      .orderBy(webhookDeliveries.createdAt)
+      .limit(limit);
+  }
+}