@manablox/api-rpc 0.1.0 → 0.3.0

package/src/routers/space.ts

@@ -1,267 +0,0 @@
-import { ManabloxError } from '@manablox/core';
-import { SpaceTransferService } from '@manablox/services';
-import { z } from 'zod';
-import { authed, base, scoped, superadmin } from '../base.js';
-import type { RpcContext } from '../context.js';
-
-const uuid = z.string().uuid();
-
-const spaceSchema = z.object({
-  name: z.string().min(1).max(200),
-  machineName: z
-    .string()
-    .regex(/^[a-z][a-z0-9_-]*$/)
-    .max(64),
-  description: z.string().nullable().optional(),
-  url: z.string().url(),
-  defaultLocale: z.string().min(2).max(10).default('en'),
-  locales: z.array(z.string().min(2).max(10)).min(1).default(['en']),
-  settings: z.record(z.string(), z.unknown()).optional(),
-});
-
-/**
- * `spaces_machine_name_key` is enforced in the database, so a taken machine name arrives
- * as a Postgres unique violation and would surface as an opaque 500. Drizzle wraps the
- * driver error, so the SQLSTATE is on `cause`.
- */
-function rethrowMachineNameConflict(error: unknown, machineName: string | undefined): never {
-  const cause = (error as { cause?: { code?: string; message?: string } }).cause;
-  const code = (error as { code?: string }).code ?? cause?.code;
-  const detail = `${cause?.message ?? ''} ${(error as { message?: string }).message ?? ''}`;
-
-  if (code === '23505' && detail.includes('machine_name')) {
-    throw ManabloxError.validation(
-      [
-        {
-          key: 'space.machineName.taken',
-          path: ['machineName'],
-          params: { machineName: machineName ?? '' },
-        },
-      ],
-      'space.validation.failed',
-    );
-  }
-  throw error;
-}
-
-/**
- * A space with no owner can never be granted one again: `user:write` is an owner's and an
- * admin's permission, and an admin cannot promote themselves past their own role.
- */
-async function assertNotLastOwner(
-  context: Pick<RpcContext, 'repos'>,
-  spaceId: string,
-  userId: string,
-): Promise<void> {
-  if ((await context.repos.users.roleIn(userId, spaceId)) !== 'owner') return;
-  const owners = (await context.repos.users.membersOf(spaceId)).filter(
-    (member) => member.role === 'owner',
-  );
-  if (owners.length <= 1) throw ManabloxError.badRequest('space.member.lastOwner', { spaceId });
-}
-
-/**
- * The default locale names the column content falls back to, so a default outside the
- * space's own locale set would leave every document with no readable fallback.
- */
-function assertDefaultIsALocale(defaultLocale: string, locales: readonly string[]): void {
-  if (locales.includes(defaultLocale)) return;
-  throw ManabloxError.validation(
-    [
-      {
-        key: 'space.defaultLocale.notInLocales',
-        path: ['defaultLocale'],
-        params: { defaultLocale, locales: locales.join(', ') },
-      },
-    ],
-    'space.validation.failed',
-  );
-}
-
-export const spaceRouter = {
-  /** Only the spaces the caller is a member of — a superadmin sees all. */
-  list: authed.handler(async ({ context }) => {
-    const all = await context.repos.spaces.all();
-    const allowed = context.principal?.allowedSpaceIds;
-    const visible = allowed ? all.filter((space) => allowed.includes(space.id)) : all;
-    if (context.principal?.role === 'superadmin') return visible;
-    return visible.filter((space) => Boolean(context.principal?.spaces[space.id]));
-  }),
-
-  get: scoped('space:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.repos.spaces.findById(input.spaceId)),
-
-  create: superadmin.input(spaceSchema).handler(async ({ input, context }) => {
-    assertDefaultIsALocale(input.defaultLocale, input.locales);
-    const space = await context.repos.spaces
-      .create(input)
-      .catch((error) => rethrowMachineNameConflict(error, input.machineName));
-    // Whoever creates a space owns it, or they would immediately lock themselves out.
-    if (context.principal) {
-      await context.repos.users.grant(context.principal.userId, space.id, 'owner');
-    }
-    return space;
-  }),
-
-  update: scoped('space:write')
-    .input(spaceSchema.partial().extend({ spaceId: uuid }))
-    .handler(async ({ input, context }) => {
-      const { spaceId, ...data } = input;
-
-      // A partial update may move either half of the pair, so the check runs against the
-      // stored values for whichever half this call leaves alone.
-      if (data.defaultLocale || data.locales) {
-        const current = await context.repos.spaces.findById(spaceId);
-        if (!current) throw ManabloxError.notFound('space.notFound', { spaceId });
-        assertDefaultIsALocale(
-          data.defaultLocale ?? current.defaultLocale,
-          data.locales ?? current.locales,
-        );
-      }
-
-      return context.repos.spaces
-        .update(spaceId, data)
-        .catch((error) => rethrowMachineNameConflict(error, data.machineName));
-    }),
-
-  delete: scoped('space:delete')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.repos.spaces.delete(input.spaceId);
-      return { ok: true };
-    }),
-
-  /**
-   * Nominates one document as the space's root. Stored in `settings` rather than on the
-   * content row so it survives the document being renamed, re-slugged or moved, and so a
-   * space has exactly one by construction.
-   *
-   * The delivery APIs resolve the empty path through it, matching the requested locale by
-   * localization group — pass `null` to clear.
-   */
-  setHome: scoped('space:write')
-    .input(z.object({ spaceId: uuid, contentId: uuid.nullable() }))
-    .handler(async ({ input, context }) => {
-      const space = await context.repos.spaces.findById(input.spaceId);
-      if (!space) throw ManabloxError.notFound('space.notFound', { spaceId: input.spaceId });
-
-      if (input.contentId) {
-        const row = await context.repos.content.findById(input.contentId);
-        if (!row || row.spaceId !== input.spaceId) {
-          throw ManabloxError.badRequest('content.notInSpace', { id: input.contentId });
-        }
-      }
-
-      const settings = { ...space.settings };
-      if (input.contentId) settings.homeContentId = input.contentId;
-      else delete settings.homeContentId;
-
-      return context.repos.spaces.update(input.spaceId, { settings });
-    }),
-
-  /**
-   * The whole space as one JSON document: its settings, its runtime content types, every
-   * document and the asset metadata. `space:write` rather than `space:read` because an
-   * export is every field of every document in one file, regardless of who may read what.
-   */
-  export: scoped('space:write')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) =>
-      new SpaceTransferService(context.manablox, context.repos).export(input.spaceId),
-    ),
-
-  /**
-   * Restores such a document, ids and all, into an instance that does not hold the space
-   * yet. Superadmin, because it creates a space — the same bar as `create`.
-   */
-  import: superadmin
-    .input(z.object({ payload: z.unknown() }))
-    .handler(async ({ input, context }) => {
-      const result = await new SpaceTransferService(context.manablox, context.repos).import(
-        input.payload,
-        context.principal.userId,
-      );
-      // Whoever imports a space owns it, exactly as if they had created it by hand.
-      await context.repos.users.grant(context.principal.userId, result.spaceId, 'owner');
-      return result;
-    }),
-
-  members: scoped('user:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.repos.users.membersOf(input.spaceId)),
-
-  grant: scoped('user:write')
-    .input(
-      z.object({
-        spaceId: uuid,
-        userId: uuid,
-        role: z.enum(['owner', 'admin', 'editor', 'author', 'viewer']),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      // Demoting the last owner locks the space out of ownership just as removing them does.
-      if (input.role !== 'owner') {
-        await assertNotLastOwner(context, input.spaceId, input.userId);
-      }
-      await context.repos.users.grant(input.userId, input.spaceId, input.role);
-      return { ok: true };
-    }),
-
-  /**
-   * Users who are not yet members, for the add-member picker. Scoped to `user:write` and
-   * returning only a name, an email and an id: a space admin needs to pick a colleague
-   * without being handed the instance's user directory, which is superadmin-only.
-   */
-  candidates: scoped('user:write')
-    .input(z.object({ spaceId: uuid, search: z.string().max(200).optional() }))
-    .handler(async ({ input, context }) => {
-      const [members, all] = await Promise.all([
-        context.repos.users.membersOf(input.spaceId),
-        context.repos.users.list({ limit: 100, offset: 0 }, input.search),
-      ]);
-      const taken = new Set(members.map((member) => member.userId));
-      return all.items
-        .filter((user) => !taken.has(user.id))
-        .map((user) => ({ id: user.id, name: user.name, email: user.email }));
-    }),
-
-  /** Grants the same role to several users at once, as the picker hands them over. */
-  addMembers: scoped('user:write')
-    .input(
-      z.object({
-        spaceId: uuid,
-        userIds: z.array(uuid).min(1).max(100),
-        role: z.enum(['owner', 'admin', 'editor', 'author', 'viewer']).default('editor'),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      // Already-members are skipped rather than rejected: the picker offers only
-      // non-members, so an overlap means the list went stale, not that the caller erred.
-      const members = await context.repos.users.membersOf(input.spaceId);
-      const taken = new Set(members.map((member) => member.userId));
-      const added = input.userIds.filter((userId) => !taken.has(userId));
-
-      for (const userId of added) {
-        await context.repos.users.grant(userId, input.spaceId, input.role);
-      }
-      return { ok: true, added: added.length };
-    }),
-
-  revoke: scoped('user:write')
-    .input(z.object({ spaceId: uuid, userId: uuid }))
-    .handler(async ({ input, context }) => {
-      await assertNotLastOwner(context, input.spaceId, input.userId);
-      await context.repos.users.revoke(input.userId, input.spaceId);
-      return { ok: true };
-    }),
-
-  /** Locales available for a space, for the editor's language switcher. */
-  locales: base.input(z.object({ spaceId: uuid })).handler(async ({ input, context }) => {
-    const space = await context.repos.spaces.findById(input.spaceId);
-    return {
-      available: space?.locales ?? context.manablox.config.locales.available,
-      default: space?.defaultLocale ?? context.manablox.config.locales.default,
-    };
-  }),
-};

package/src/routers/user.ts

@@ -1,68 +0,0 @@
-import { assertCan } from '@manablox/auth';
-import { z } from 'zod';
-import { authed, superadmin } from '../base.js';
-
-const uuid = z.string().uuid();
-
-export const userRouter = {
-  me: authed.handler(async ({ context }) => {
-    const user = await context.repos.users.findById(context.principal.userId);
-    return user
-      ? {
-          id: user.id,
-          email: user.email,
-          name: user.name,
-          image: user.image,
-          role: user.role,
-          spaces: context.principal.spaces,
-        }
-      : null;
-  }),
-
-  list: superadmin
-    .input(
-      z.object({
-        search: z.string().max(200).optional(),
-        limit: z.number().int().min(1).max(100).default(25),
-        offset: z.number().int().min(0).default(0),
-      }),
-    )
-    .handler(async ({ input, context }) =>
-      context.repos.users.list({ limit: input.limit, offset: input.offset }, input.search),
-    ),
-
-  setRole: superadmin
-    .input(z.object({ userId: uuid, role: z.enum(['superadmin', 'editor']) }))
-    .handler(async ({ input, context }) => context.repos.users.setRole(input.userId, input.role)),
-
-  apiKeys: authed.handler(async ({ context }) => context.apiKeys.list(context.principal.userId)),
-
-  issueApiKey: authed
-    .input(
-      z.object({
-        name: z.string().min(1).max(100),
-        expiresAt: z.coerce.date().optional(),
-        /** Empty or omitted issues an unrestricted key. */
-        spaceIds: z.array(uuid).optional(),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      // A key may only be confined to spaces the issuer can already reach, so a
-      // restriction cannot be used to name a space the caller has no business knowing.
-      for (const spaceId of input.spaceIds ?? []) {
-        assertCan(context.principal, spaceId, 'space:read');
-      }
-      return context.apiKeys.issue(context.principal.userId, input.name, {
-        expiresAt: input.expiresAt,
-        spaceIds: input.spaceIds,
-      });
-    }),
-
-  revokeApiKey: authed.input(z.object({ id: uuid })).handler(async ({ input, context }) => {
-    // Scope the revoke to the caller's own keys so an id from elsewhere is inert.
-    const own = await context.apiKeys.list(context.principal.userId);
-    if (!own.some((key) => key.id === input.id)) return { ok: false };
-    await context.apiKeys.revoke(input.id);
-    return { ok: true };
-  }),
-};

package/tsconfig.json

@@ -1 +0,0 @@
-{ "extends": "@manablox/config-typescript/library.json", "include": ["src", "test"] }