@manablox/api-rpc 0.2.0 → 0.4.0

package/test/helpers.ts

@@ -1,163 +0,0 @@
-import { type Principal, UserService } from '@manablox/auth';
-import { RoleService, SpaceService } from '@manablox/services';
-import { call } from '@orpc/server';
-import { type Mock, vi } from 'vitest';
-import type { RpcContext } from '../src/context.js';
-
-export const SPACE_ID = '11111111-1111-4111-8111-111111111111';
-export const OTHER_SPACE_ID = '22222222-2222-4222-8222-222222222222';
-export const USER_ID = '33333333-3333-4333-8333-333333333333';
-export const OTHER_USER_ID = '44444444-4444-4444-8444-444444444444';
-export const TYPE_ID = '55555555-5555-4555-8555-555555555555';
-
-export function principal(overrides: Partial<Principal> = {}): Principal {
-  return {
-    userId: USER_ID,
-    email: 'owner@example.com',
-    role: 'editor',
-    spaces: { [SPACE_ID]: 'owner' },
-    ...overrides,
-  };
-}
-
-export const superadmin = (): Principal =>
-  principal({ role: 'superadmin', email: 'root@example.com', spaces: {} });
-
-/**
- * A context whose repositories are all mocks. Each test wires only the calls it needs;
- * anything else throws, which is the point — a handler reaching for a repository the
- * test did not expect is a behaviour change.
- */
-export interface StubRepos {
-  spaces: Record<
-    'all' | 'findManyByIds' | 'findById' | 'findByMachineName' | 'create' | 'update' | 'delete',
-    Mock
-  >;
-  users: Record<
-    | 'findById'
-    | 'list'
-    | 'count'
-    | 'countByRole'
-    | 'membersOf'
-    | 'membershipsWithSpaces'
-    | 'roleIn'
-    | 'grant'
-    | 'revoke'
-    | 'setRole'
-    | 'create'
-    | 'update'
-    | 'delete'
-    | 'setBanned'
-    | 'setPasswordHash'
-    | 'revokeSessions',
-    Mock
-  >;
-  content: Record<'findById', Mock>;
-  roles: Record<
-    | 'listBySpace'
-    | 'findById'
-    | 'findByMachineName'
-    | 'create'
-    | 'update'
-    | 'delete'
-    | 'countMembers'
-    | 'pruneContentType',
-    Mock
-  >;
-}
-
-/** The mocks behind a stub context, typed so a test can arrange them without casts. */
-export function mocks(context: RpcContext): StubRepos {
-  return context.repos as unknown as StubRepos;
-}
-
-export function stubContext(overrides: Partial<RpcContext> = {}): RpcContext {
-  const repos = {
-    spaces: {
-      all: vi.fn(),
-      findManyByIds: vi.fn(),
-      findById: vi.fn(),
-      findByMachineName: vi.fn(),
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-    },
-    users: {
-      findById: vi.fn(),
-      list: vi.fn(),
-      count: vi.fn(),
-      countByRole: vi.fn(),
-      membersOf: vi.fn(),
-      membershipsWithSpaces: vi.fn(),
-      roleIn: vi.fn(),
-      grant: vi.fn(),
-      revoke: vi.fn(),
-      setRole: vi.fn(),
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-      setBanned: vi.fn(),
-      setPasswordHash: vi.fn(),
-      revokeSessions: vi.fn(),
-    },
-    content: { findById: vi.fn() },
-    roles: {
-      listBySpace: vi.fn(),
-      findById: vi.fn(),
-      findByMachineName: vi.fn(),
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-      countMembers: vi.fn(),
-      pruneContentType: vi.fn(),
-    },
-  };
-
-  const manablox = {
-    config: { locales: { default: 'en', available: ['en'] } },
-    contentTypes: { forSpace: () => [{ id: TYPE_ID }] },
-  };
-  const roles = new RoleService(manablox as never, repos as never);
-  return {
-    manablox,
-    repos,
-    // The real service over the mocked repositories: the rules are what the tests assert.
-    spaces: new SpaceService(manablox as never, repos as never, roles),
-    roles,
-    users: new UserService(repos as never),
-    auth: {},
-    apiKeys: { list: vi.fn(), issue: vi.fn(), revoke: vi.fn() },
-    media: {},
-    content: {},
-    contentTypes: {},
-    loaders: {},
-    principal: principal(),
-    headers: new Headers(),
-    ...overrides,
-  } as unknown as RpcContext;
-}
-
-/** Calls a procedure the way the transport would, with the mapped error surfaced. */
-export function invoke<T>(procedure: unknown, input: unknown, context: RpcContext): Promise<T> {
-  return call(procedure as never, input as never, { context }) as Promise<T>;
-}
-
-export async function failure(
-  promise: Promise<unknown>,
-): Promise<{ code: string; key: string; details?: Array<{ key: string; path?: unknown[] }> }> {
-  try {
-    await promise;
-  } catch (error) {
-    const e = error as {
-      code: string;
-      data?: { key?: string; details?: Array<{ key: string; path?: unknown[] }> };
-      message: string;
-    };
-    return {
-      code: e.code,
-      key: e.data?.key ?? e.message,
-      ...(e.data?.details ? { details: e.data.details } : {}),
-    };
-  }
-  throw new Error('expected the call to fail');
-}

package/test/menu.test.ts

@@ -1,192 +0,0 @@
-import { ManabloxError } from '@manablox/core';
-import { describe, expect, it, vi } from 'vitest';
-import { menuRouter } from '../src/routers/menu.js';
-import { failure, invoke, principal, SPACE_ID, stubContext } from './helpers.js';
-
-const MENU_ID = '88888888-8888-4888-8888-888888888888';
-const LOC_ID = '99999999-9999-4999-8999-999999999999';
-
-const menu = (overrides = {}) => ({
-  id: MENU_ID,
-  spaceId: SPACE_ID,
-  name: 'Main',
-  machineName: 'main',
-  description: null,
-  ...overrides,
-});
-
-/** The router is input + permission + one service call; the service itself is a mock. */
-function menus() {
-  return {
-    list: vi.fn(),
-    get: vi.fn(),
-    create: vi.fn(),
-    update: vi.fn(),
-    delete: vi.fn(),
-    setItems: vi.fn(),
-    usedIn: vi.fn(),
-  };
-}
-
-describe('menus.list / get', () => {
-  it('passes the space and the locale through to the service', async () => {
-    const service = menus();
-    service.list.mockResolvedValue([menu()]);
-    service.get.mockResolvedValue({ menu: menu(), items: [] });
-    const ctx = stubContext({ menus: service as never });
-
-    expect(await invoke(menuRouter.list, { spaceId: SPACE_ID }, ctx)).toEqual([menu()]);
-    await invoke(menuRouter.get, { spaceId: SPACE_ID, id: MENU_ID, locale: 'de' }, ctx);
-    expect(service.get).toHaveBeenCalledWith(SPACE_ID, MENU_ID, 'de');
-  });
-
-  it('needs menu:read, which a member of another space lacks', async () => {
-    const ctx = stubContext({
-      menus: menus() as never,
-      principal: principal({ spaces: {} }),
-    });
-    expect(await failure(invoke(menuRouter.list, { spaceId: SPACE_ID }, ctx))).toMatchObject({
-      code: 'FORBIDDEN',
-    });
-  });
-
-  it('is closed without a principal', async () => {
-    const ctx = stubContext({ menus: menus() as never, principal: null });
-    expect(await failure(invoke(menuRouter.list, { spaceId: SPACE_ID }, ctx))).toMatchObject({
-      code: 'UNAUTHORIZED',
-    });
-  });
-});
-
-describe('menus.create / update / delete', () => {
-  it('needs menu:write, which a viewer lacks and an editor holds', async () => {
-    const service = menus();
-    service.create.mockResolvedValue(menu());
-    const input = { spaceId: SPACE_ID, name: 'Main', machineName: 'main' };
-
-    const viewer = stubContext({
-      menus: service as never,
-      principal: principal({ spaces: { [SPACE_ID]: 'viewer' } }),
-    });
-    expect(await failure(invoke(menuRouter.create, input, viewer))).toMatchObject({
-      code: 'FORBIDDEN',
-    });
-
-    const editor = stubContext({
-      menus: service as never,
-      principal: principal({ spaces: { [SPACE_ID]: 'editor' } }),
-    });
-    expect(await invoke(menuRouter.create, input, editor)).toEqual(menu());
-    expect(service.create).toHaveBeenCalledWith(input);
-  });
-
-  it('rejects a machine name that is not technical before the service sees it', async () => {
-    const service = menus();
-    const ctx = stubContext({ menus: service as never });
-    const result = await failure(
-      invoke(menuRouter.create, { spaceId: SPACE_ID, name: 'Main', machineName: 'Main Nav' }, ctx),
-    );
-    expect(result.code).toBe('BAD_REQUEST');
-    expect(service.create).not.toHaveBeenCalled();
-  });
-
-  it('maps a service validation error to BAD_REQUEST with its details', async () => {
-    const service = menus();
-    service.create.mockRejectedValue(
-      ManabloxError.validation(
-        [{ key: 'menu.machineName.taken', path: ['machineName'], params: { machineName: 'main' } }],
-        'menu.validation.failed',
-      ),
-    );
-    const ctx = stubContext({ menus: service as never });
-    const result = await failure(
-      invoke(menuRouter.create, { spaceId: SPACE_ID, name: 'Main', machineName: 'main' }, ctx),
-    );
-    expect(result).toMatchObject({
-      code: 'BAD_REQUEST',
-      key: 'menu.validation.failed',
-      details: [{ key: 'menu.machineName.taken', path: ['machineName'] }],
-    });
-  });
-
-  it('splits the update into the space, the id and the data', async () => {
-    const service = menus();
-    service.update.mockResolvedValue(menu({ name: 'Primary' }));
-    const ctx = stubContext({ menus: service as never });
-    await invoke(menuRouter.update, { spaceId: SPACE_ID, id: MENU_ID, name: 'Primary' }, ctx);
-    expect(service.update).toHaveBeenCalledWith(SPACE_ID, MENU_ID, { name: 'Primary' });
-  });
-
-  it('maps a missing menu to NOT_FOUND and answers a delete with ok', async () => {
-    const service = menus();
-    service.delete.mockRejectedValueOnce(ManabloxError.notFound('menu.notFound', { id: MENU_ID }));
-    service.delete.mockResolvedValueOnce(undefined);
-    const ctx = stubContext({ menus: service as never });
-    expect(
-      await failure(invoke(menuRouter.delete, { spaceId: SPACE_ID, id: MENU_ID }, ctx)),
-    ).toMatchObject({ code: 'NOT_FOUND', key: 'menu.notFound' });
-    expect(await invoke(menuRouter.delete, { spaceId: SPACE_ID, id: MENU_ID }, ctx)).toEqual({
-      ok: true,
-    });
-  });
-});
-
-describe('menus.setItems', () => {
-  it('accepts a nested tree of documents and links and hands it over whole', async () => {
-    const service = menus();
-    service.setItems.mockResolvedValue([]);
-    const ctx = stubContext({ menus: service as never });
-    const items = [
-      {
-        localizationId: LOC_ID,
-        children: [{ url: 'https://blog.example', label: 'Blog', children: [] }],
-      },
-    ];
-    await invoke(menuRouter.setItems, { spaceId: SPACE_ID, id: MENU_ID, items }, ctx);
-    expect(service.setItems).toHaveBeenCalledWith(SPACE_ID, MENU_ID, items);
-  });
-
-  it('refuses an entry whose localization id is not a uuid', async () => {
-    const service = menus();
-    const ctx = stubContext({ menus: service as never });
-    const result = await failure(
-      invoke(
-        menuRouter.setItems,
-        { spaceId: SPACE_ID, id: MENU_ID, items: [{ localizationId: 'nope' }] },
-        ctx,
-      ),
-    );
-    expect(result.code).toBe('BAD_REQUEST');
-    expect(service.setItems).not.toHaveBeenCalled();
-  });
-
-  it('surfaces the service’s positional error paths untouched', async () => {
-    const service = menus();
-    service.setItems.mockRejectedValue(
-      ManabloxError.validation(
-        [{ key: 'menu.item.linkNeedsLabel', path: ['items', 0, 'children', 1] }],
-        'menu.validation.failed',
-      ),
-    );
-    const ctx = stubContext({ menus: service as never });
-    const result = await failure(
-      invoke(menuRouter.setItems, { spaceId: SPACE_ID, id: MENU_ID, items: [] }, ctx),
-    );
-    expect(result.details?.[0]?.path).toEqual(['items', 0, 'children', 1]);
-  });
-});
-
-describe('menus.usedIn', () => {
-  it('asks for the menus referencing a localization', async () => {
-    const service = menus();
-    service.usedIn.mockResolvedValue([menu()]);
-    const ctx = stubContext({ menus: service as never });
-    const result = await invoke(
-      menuRouter.usedIn,
-      { spaceId: SPACE_ID, localizationId: LOC_ID },
-      ctx,
-    );
-    expect(result).toEqual([menu()]);
-    expect(service.usedIn).toHaveBeenCalledWith(SPACE_ID, LOC_ID);
-  });
-});

package/test/role.test.ts

@@ -1,205 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { contentRouter } from '../src/routers/content.js';
-import { roleRouter } from '../src/routers/role.js';
-import { spaceRouter } from '../src/routers/space.js';
-import {
-  failure,
-  invoke,
-  mocks,
-  OTHER_USER_ID,
-  principal,
-  SPACE_ID,
-  stubContext,
-  TYPE_ID,
-} from './helpers.js';
-
-const ROLE_ID = '66666666-6666-4666-8666-666666666666';
-const OTHER_TYPE_ID = '77777777-7777-4777-8777-777777777777';
-
-const row = (overrides = {}) => ({
-  id: ROLE_ID,
-  spaceId: SPACE_ID,
-  name: 'Blogger',
-  machineName: 'blogger',
-  description: null,
-  permissions: ['space:read', `content:write:${TYPE_ID}`],
-  createdAt: new Date(),
-  updatedAt: new Date(),
-  ...overrides,
-});
-
-describe('roles.list', () => {
-  it('lists the built-in roles ahead of the space’s own', async () => {
-    const ctx = stubContext();
-    mocks(ctx).roles.listBySpace.mockResolvedValue([row()]);
-    const list = await invoke<Array<{ machineName: string; builtIn: boolean }>>(
-      roleRouter.list,
-      { spaceId: SPACE_ID },
-      ctx,
-    );
-    expect(list.map((role) => role.machineName)).toEqual([
-      'owner',
-      'admin',
-      'editor',
-      'author',
-      'viewer',
-      'blogger',
-    ]);
-    expect(list.filter((role) => role.builtIn)).toHaveLength(5);
-  });
-
-  it('needs role:read, which an author lacks', async () => {
-    const ctx = stubContext({ principal: principal({ spaces: { [SPACE_ID]: 'author' } }) });
-    expect(await failure(invoke(roleRouter.list, { spaceId: SPACE_ID }, ctx))).toMatchObject({
-      code: 'FORBIDDEN',
-    });
-  });
-});
-
-describe('roles.create', () => {
-  it('refuses a built-in name, a bad grant and a type the space lacks — each at its path', async () => {
-    const ctx = stubContext();
-    const result = await failure(
-      invoke(
-        roleRouter.create,
-        {
-          spaceId: SPACE_ID,
-          name: 'Owner again',
-          machineName: 'owner',
-          permissions: ['content:write', 'nope:really', `content:read:${OTHER_TYPE_ID}`],
-        },
-        ctx,
-      ),
-    );
-    expect(result.key).toBe('role.validation.failed');
-    expect(result.details?.map((detail) => [detail.key, detail.path])).toEqual([
-      ['role.machineName.reserved', ['machineName']],
-      ['role.permission.unknown', ['permissions', 1]],
-      ['role.permission.unknown', ['permissions', 2]],
-    ]);
-    expect(mocks(ctx).roles.create).not.toHaveBeenCalled();
-  });
-
-  it('always includes the reads the admin cannot render without', async () => {
-    const ctx = stubContext();
-    mocks(ctx).roles.create.mockImplementation(async (_spaceId, data) => row(data));
-    const created = await invoke<{ permissions: string[] }>(
-      roleRouter.create,
-      {
-        spaceId: SPACE_ID,
-        name: 'Blogger',
-        machineName: 'blogger',
-        permissions: [`content:write:${TYPE_ID}`],
-      },
-      ctx,
-    );
-    expect(created.permissions).toEqual([
-      'space:read',
-      'contentType:read',
-      `content:write:${TYPE_ID}`,
-    ]);
-  });
-});
-
-describe('roles.delete', () => {
-  it('refuses while a member still holds the role', async () => {
-    const ctx = stubContext();
-    mocks(ctx).roles.findById.mockResolvedValue(row());
-    mocks(ctx).roles.countMembers.mockResolvedValue(2);
-    expect(
-      await failure(invoke(roleRouter.delete, { spaceId: SPACE_ID, id: ROLE_ID }, ctx)),
-    ).toMatchObject({ code: 'CONFLICT', key: 'role.inUse' });
-    expect(mocks(ctx).roles.delete).not.toHaveBeenCalled();
-  });
-});
-
-describe('memberships and custom roles', () => {
-  it('grants a custom role that exists and refuses one that does not', async () => {
-    const ctx = stubContext();
-    const repos = mocks(ctx);
-    repos.users.roleIn.mockResolvedValue('editor');
-    repos.roles.findByMachineName.mockImplementation(async (_space, name) =>
-      name === 'blogger' ? row() : null,
-    );
-
-    await invoke(
-      spaceRouter.grant,
-      { spaceId: SPACE_ID, userId: OTHER_USER_ID, role: 'blogger' },
-      ctx,
-    );
-    expect(repos.users.grant).toHaveBeenCalledWith(OTHER_USER_ID, SPACE_ID, 'blogger');
-
-    expect(
-      await failure(
-        invoke(spaceRouter.grant, { spaceId: SPACE_ID, userId: OTHER_USER_ID, role: 'ghost' }, ctx),
-      ),
-    ).toMatchObject({ key: 'space.member.roleNotFound' });
-  });
-});
-
-describe('content permissions narrowed to a type', () => {
-  const blogger = () =>
-    principal({
-      spaces: { [SPACE_ID]: 'blogger' },
-      permissions: {
-        [SPACE_ID]: ['space:read', `content:read:${TYPE_ID}`, `content:write:${TYPE_ID}`],
-      },
-    });
-
-  it('lets the role write its type and refuses another', async () => {
-    const ctx = stubContext({
-      principal: blogger(),
-      content: { create: async (input: unknown) => input } as never,
-    });
-    const save = { spaceId: SPACE_ID, typeId: TYPE_ID, title: 'Post', fields: {} };
-    await expect(invoke(contentRouter.create, save, ctx)).resolves.toMatchObject({ title: 'Post' });
-    expect(
-      await failure(invoke(contentRouter.create, { ...save, typeId: OTHER_TYPE_ID }, ctx)),
-    ).toMatchObject({ code: 'FORBIDDEN' });
-  });
-
-  it('checks a document’s own type before deleting it', async () => {
-    const ctx = stubContext({
-      principal: principal({
-        spaces: { [SPACE_ID]: 'blogger' },
-        permissions: { [SPACE_ID]: ['space:read', `content:delete:${TYPE_ID}`] },
-      }),
-      content: { delete: async () => 1 } as never,
-    });
-    const id = '88888888-8888-4888-8888-888888888888';
-    mocks(ctx).content.findById.mockResolvedValue({ id, spaceId: SPACE_ID, typeId: OTHER_TYPE_ID });
-    expect(
-      await failure(invoke(contentRouter.delete, { spaceId: SPACE_ID, id }, ctx)),
-    ).toMatchObject({
-      code: 'FORBIDDEN',
-    });
-
-    mocks(ctx).content.findById.mockResolvedValue({ id, spaceId: SPACE_ID, typeId: TYPE_ID });
-    await expect(invoke(contentRouter.delete, { spaceId: SPACE_ID, id }, ctx)).resolves.toEqual({
-      deleted: 1,
-    });
-  });
-
-  it('narrows a listing to the readable types, and answers an empty page for the rest', async () => {
-    const seen: unknown[] = [];
-    const ctx = stubContext({
-      principal: blogger(),
-      content: {
-        list: async (filter: unknown) => {
-          seen.push(filter);
-          return { items: [], total: 0, limit: 25, offset: 0 };
-        },
-      } as never,
-    });
-    await invoke(contentRouter.list, { filter: { spaceId: SPACE_ID } }, ctx);
-    expect(seen[0]).toMatchObject({ typeIds: [TYPE_ID] });
-
-    const empty = await invoke<{ total: number }>(
-      contentRouter.list,
-      { filter: { spaceId: SPACE_ID, typeIds: [OTHER_TYPE_ID] } },
-      ctx,
-    );
-    expect(empty.total).toBe(0);
-    expect(seen).toHaveLength(1);
-  });
-});