@manablox/db 0.1.0

package/src/repositories/index.ts

@@ -0,0 +1,28 @@
+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 { SpaceRepository } from './space.js';
+import { UserRepository } from './user.js';
+
+export interface Repositories {
+  content: ContentRepository;
+  contentTypes: ContentTypeRepository;
+  spaces: SpaceRepository;
+  assets: AssetRepository;
+  assetUsages: AssetUsageRepository;
+  users: UserRepository;
+}
+
+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),
+  };
+}

package/src/repositories/space.ts

@@ -0,0 +1,78 @@
+import { type Loose, ManabloxError } from '@manablox/core';
+import { eq } from 'drizzle-orm';
+import type { Database } from '../client.js';
+import { type SpaceRow, spaces } from '../schema.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 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));
+  }
+}

package/src/repositories/user.ts

@@ -0,0 +1,134 @@
+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';
+
+export type SpaceRole = 'owner' | 'admin' | 'editor' | 'author' | 'viewer';
+
+export class UserRepository {
+  constructor(private readonly db: Database) {}
+
+  async findById(id: string): Promise<UserRow | null> {
+    const rows = await this.db.select().from(users).where(eq(users.id, id)).limit(1);
+    return rows[0] ?? null;
+  }
+
+  async findManyByIds(ids: string[]): Promise<UserRow[]> {
+    if (ids.length === 0) return [];
+    return this.db.select().from(users).where(inArray(users.id, ids));
+  }
+
+  async findByEmail(email: string): Promise<UserRow | null> {
+    const rows = await this.db.select().from(users).where(eq(users.email, email)).limit(1);
+    return rows[0] ?? null;
+  }
+
+  async list(pagination: Pagination, search?: string): Promise<Paginated<UserRow>> {
+    const where = search
+      ? 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,
+    };
+  }
+
+  async count(): Promise<number> {
+    const rows = await this.db.select({ count: sql<number>`count(*)::int` }).from(users);
+    return rows[0]?.count ?? 0;
+  }
+
+  async setRole(id: string, role: string): Promise<UserRow> {
+    const [row] = await this.db
+      .update(users)
+      .set({ role, updatedAt: new Date() })
+      .where(eq(users.id, id))
+      .returning();
+    if (!row) throw ManabloxError.notFound('user.notFound', { id });
+    return row;
+  }
+
+  // --- space membership -----------------------------------------------------
+
+  /**
+   * Authoritative role plus space memberships in one query.
+   *
+   * 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.
+   */
+  async principal(
+    userId: string,
+  ): Promise<{ role: string; banned: boolean; spaces: Record<string, SpaceRole> } | null> {
+    const rows = await this.db
+      .select({
+        role: users.role,
+        banned: users.banned,
+        spaceId: memberships.spaceId,
+        spaceRole: memberships.role,
+      })
+      .from(users)
+      .leftJoin(memberships, eq(memberships.userId, users.id))
+      .where(eq(users.id, userId));
+
+    const first = rows[0];
+    if (!first) return null;
+
+    const spaces: Record<string, SpaceRole> = {};
+    for (const row of rows) {
+      if (row.spaceId && row.spaceRole) spaces[row.spaceId] = row.spaceRole;
+    }
+
+    return { role: first.role, banned: first.banned, spaces };
+  }
+
+  async memberships(userId: string): Promise<MembershipRow[]> {
+    return this.db.select().from(memberships).where(eq(memberships.userId, userId));
+  }
+
+  async membersOf(spaceId: string): Promise<Array<MembershipRow & { user: UserRow }>> {
+    const rows = await this.db
+      .select({ membership: memberships, user: users })
+      .from(memberships)
+      .innerJoin(users, eq(users.id, memberships.userId))
+      .where(eq(memberships.spaceId, spaceId));
+    return rows.map((row) => ({ ...row.membership, user: row.user }));
+  }
+
+  async roleIn(userId: string, spaceId: string): Promise<SpaceRole | null> {
+    const rows = await this.db
+      .select({ role: memberships.role })
+      .from(memberships)
+      .where(and(eq(memberships.userId, userId), eq(memberships.spaceId, spaceId)))
+      .limit(1);
+    return rows[0]?.role ?? null;
+  }
+
+  async grant(userId: string, spaceId: string, role: SpaceRole): Promise<void> {
+    await this.db
+      .insert(memberships)
+      .values({ userId, spaceId, role })
+      .onConflictDoUpdate({ target: [memberships.userId, memberships.spaceId], set: { role } });
+  }
+
+  async revoke(userId: string, spaceId: string): Promise<void> {
+    await this.db
+      .delete(memberships)
+      .where(and(eq(memberships.userId, userId), eq(memberships.spaceId, spaceId)));
+  }
+}