@manablox/api-rpc 0.2.0 → 0.3.0

package/src/routers/menu.ts

@@ -1,77 +0,0 @@
-import { z } from 'zod';
-import { scoped } from '../base.js';
-import { locale, machineName, uuid } from '../schemas.js';
-
-const menuSchema = z.object({
-  name: z.string().min(1).max(200),
-  machineName,
-  description: z.string().max(2000).nullable().optional(),
-});
-
-/** One entry as the editor hands it over: a document by localization id, or a link. */
-export interface MenuItemInputShape {
-  id?: string | undefined;
-  localizationId?: string | null | undefined;
-  label?: string | null | undefined;
-  url?: string | null | undefined;
-  children?: MenuItemInputShape[] | undefined;
-}
-
-const menuItemSchema: z.ZodType<MenuItemInputShape> = z.lazy(() =>
-  z.object({
-    id: uuid.optional(),
-    localizationId: uuid.nullable().optional(),
-    label: z.string().max(200).nullable().optional(),
-    url: z.string().max(2000).nullable().optional(),
-    children: z.array(menuItemSchema).max(500).optional(),
-  }),
-);
-
-/**
- * Menus. Each rule — the unique machine name, what an entry may point at — lives in
- * `MenuService`; a procedure here is an input schema, a permission and one call.
- */
-export const menuRouter = {
-  list: scoped('menu:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.menus.list(input.spaceId)),
-
-  /** The menu with its entries, each content entry resolved to the document in `locale`. */
-  get: scoped('menu:read')
-    .input(z.object({ spaceId: uuid, id: uuid, locale }))
-    .handler(async ({ input, context }) =>
-      context.menus.get(input.spaceId, input.id, input.locale),
-    ),
-
-  create: scoped('menu:write')
-    .input(menuSchema.extend({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.menus.create(input)),
-
-  update: scoped('menu:write')
-    .input(menuSchema.partial().extend({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      const { spaceId, id, ...data } = input;
-      return context.menus.update(spaceId, id, data);
-    }),
-
-  delete: scoped('menu:write')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.menus.delete(input.spaceId, input.id);
-      return { ok: true };
-    }),
-
-  /** Replaces the whole entry tree; the editor saves a menu as one document. */
-  setItems: scoped('menu:write')
-    .input(z.object({ spaceId: uuid, id: uuid, items: z.array(menuItemSchema).max(500) }))
-    .handler(async ({ input, context }) =>
-      context.menus.setItems(input.spaceId, input.id, input.items),
-    ),
-
-  /** Menus a document is linked from, for the editor's hint. */
-  usedIn: scoped('menu:read')
-    .input(z.object({ spaceId: uuid, localizationId: uuid }))
-    .handler(async ({ input, context }) =>
-      context.menus.usedIn(input.spaceId, input.localizationId),
-    ),
-};

package/src/routers/role.ts

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-import { authed, scoped } from '../base.js';
-import { machineName, uuid } from '../schemas.js';
-
-const roleSchema = z.object({
-  spaceId: uuid,
-  name: z.string().trim().min(1).max(100),
-  machineName,
-  description: z.string().max(500).nullable().optional(),
-  /** `space:write`, `content:read` for every type, `content:read:<typeId>` for one. */
-  permissions: z.array(z.string().max(120)).max(500),
-});
-
-/**
- * The roles of a space. The rules — reserved names, grants that exist, a role nobody
- * holds before it goes — live in `RoleService`; a procedure here is an input schema, a
- * permission and one call.
- */
-export const roleRouter = {
-  /** The permission catalogue, grouped the way the role editor lays it out. */
-  catalog: authed.handler(async ({ context }) => context.roles.catalog()),
-
-  list: scoped('role:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.roles.list(input.spaceId)),
-
-  get: scoped('role:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => context.roles.get(input.spaceId, input.id)),
-
-  create: scoped('role:write')
-    .input(roleSchema)
-    .handler(async ({ input, context }) => {
-      const { spaceId, ...data } = input;
-      return context.roles.create(spaceId, data);
-    }),
-
-  update: scoped('role:write')
-    .input(roleSchema.extend({ id: uuid }))
-    .handler(async ({ input, context }) => {
-      const { spaceId, id, ...data } = input;
-      return context.roles.update(spaceId, id, data);
-    }),
-
-  delete: scoped('role:write')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.roles.delete(input.spaceId, input.id);
-      return { ok: true };
-    }),
-};

package/src/routers/space.ts

@@ -1,149 +0,0 @@
-import { z } from 'zod';
-import { authed, base, scoped, superadmin } from '../base.js';
-import {
-  locale,
-  localeList,
-  machineName,
-  mimeTypePattern,
-  searchTerm,
-  spaceRole,
-  uuid,
-} from '../schemas.js';
-
-const spaceSchema = z.object({
-  name: z.string().min(1).max(200),
-  machineName,
-  description: z.string().nullable().optional(),
-  url: z.string().url(),
-  defaultLocale: locale.default('en'),
-  locales: localeList.default(['en']),
-  settings: z.record(z.string(), z.unknown()).optional(),
-});
-
-/**
- * Spaces and membership. Every rule — the locale invariant, the last-owner guard, the
- * creator-owns-it grant — lives in `SpaceService`; a procedure here is an input schema,
- * a permission and one call.
- */
-export const spaceRouter = {
-  /**
-   * Only the spaces the caller is a member of — a superadmin sees all. A member's query
-   * is bounded by their memberships rather than by the instance, so a large multi-tenant
-   * install does not load every space to show someone their two.
-   */
-  list: authed.handler(async ({ context }) => {
-    const { principal } = context;
-    const all =
-      principal.role === 'superadmin'
-        ? await context.repos.spaces.all()
-        : await context.repos.spaces.findManyByIds(Object.keys(principal.spaces));
-    const allowed = principal.allowedSpaceIds;
-    return allowed ? all.filter((space) => allowed.includes(space.id)) : all;
-  }),
-
-  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 }) =>
-      context.spaces.create(input, context.principal?.userId ?? null),
-    ),
-
-  update: scoped('space:write')
-    .input(spaceSchema.partial().extend({ spaceId: uuid }))
-    .handler(async ({ input, context }) => {
-      const { spaceId, ...data } = input;
-      return context.spaces.update(spaceId, data);
-    }),
-
-  delete: scoped('space:delete')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.spaces.delete(input.spaceId);
-      return { ok: true };
-    }),
-
-  /** Nominates one document as the space's root; `null` clears it. */
-  setHome: scoped('space:write')
-    .input(z.object({ spaceId: uuid, contentId: uuid.nullable() }))
-    .handler(async ({ input, context }) => context.spaces.setHome(input.spaceId, input.contentId)),
-
-  /**
-   * The space's upload limits, each narrowing the instance's. `allowedMimeTypes` absent
-   * means the instance's list; empty means the same thing rather than "nothing".
-   */
-  setAssetSettings: scoped('space:write')
-    .input(
-      z.object({
-        spaceId: uuid,
-        allowedMimeTypes: z.array(mimeTypePattern).max(50).optional(),
-        maxFileSize: z.number().int().positive().nullable().optional(),
-      }),
-    )
-    .handler(async ({ input, context }) =>
-      context.spaces.setAssetSettings(input.spaceId, {
-        ...(input.allowedMimeTypes?.length ? { allowedMimeTypes: input.allowedMimeTypes } : {}),
-        ...(input.maxFileSize ? { maxFileSize: input.maxFileSize } : {}),
-      }),
-    ),
-
-  /**
-   * The whole space as one JSON document. `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 }) => context.spaces.export(input.spaceId)),
-
-  /** Restores such a document into an instance that does not hold the space yet. Superadmin, because it creates a space. */
-  import: superadmin
-    .input(z.object({ payload: z.unknown() }))
-    .handler(async ({ input, context }) =>
-      context.spaces.import(input.payload, context.principal.userId),
-    ),
-
-  members: scoped('user:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.spaces.members(input.spaceId)),
-
-  grant: scoped('user:write')
-    .input(z.object({ spaceId: uuid, userId: uuid, role: spaceRole }))
-    .handler(async ({ input, context }) => {
-      await context.spaces.grant(input.spaceId, input.userId, input.role);
-      return { ok: true };
-    }),
-
-  /** Users who are not yet members, for the add-member picker. */
-  candidates: scoped('user:write')
-    .input(z.object({ spaceId: uuid, search: searchTerm.optional() }))
-    .handler(async ({ input, context }) => context.spaces.candidates(input.spaceId, input.search)),
-
-  /** 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: spaceRole.default('editor'),
-      }),
-    )
-    .handler(async ({ input, context }) => ({
-      ok: true,
-      added: await context.spaces.addMembers(input.spaceId, input.userIds, input.role),
-    })),
-
-  revoke: scoped('user:write')
-    .input(z.object({ spaceId: uuid, userId: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.spaces.revoke(input.spaceId, input.userId);
-      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 }) => context.spaces.locales(input.spaceId)),
-};

package/src/routers/user.ts

@@ -1,175 +0,0 @@
-import { assertCan, effectiveGrants, MIN_PASSWORD_LENGTH, normaliseGrants } from '@manablox/auth';
-import { ManabloxError } from '@manablox/core';
-import { z } from 'zod';
-import { authed, base, superadmin } from '../base.js';
-import { pagination, searchTerm, uuid } from '../schemas.js';
-
-const instanceRole = z.enum(['superadmin', 'editor']);
-const password = z.string().min(MIN_PASSWORD_LENGTH).max(200);
-const email = z.string().email().max(320);
-const displayName = z.string().trim().min(1).max(200);
-
-/**
- * The caller's own account and keys, and — for a superadmin — every account on the
- * instance. The rules (no locking yourself out, one superadmin always remains) live in
- * `UserService`; a procedure here is an input schema, a permission and one call.
- */
-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,
-          // Space id → every grant held there, built-in roles resolved too, so the admin
-          // shows and hides controls from the same table the server enforces.
-          permissions: Object.fromEntries(
-            Object.keys(context.principal.spaces).map((spaceId) => [
-              spaceId,
-              effectiveGrants(context.principal, spaceId),
-            ]),
-          ),
-        }
-      : null;
-  }),
-
-  /**
-   * Whether the instance still has no account at all. Public, because the login page
-   * needs it before anyone is signed in: it decides whether to offer "create the first
-   * account". Once one exists, sign-up is closed and every account is created here.
-   */
-  setupNeeded: base.handler(async ({ context }) => ({
-    setupNeeded: (await context.repos.users.count()) === 0,
-  })),
-
-  list: superadmin
-    .input(pagination({ limit: 25, max: 100 }).extend({ search: searchTerm.optional() }))
-    .handler(async ({ input, context }) =>
-      context.users.list({ limit: input.limit, offset: input.offset }, input.search),
-    ),
-
-  get: superadmin
-    .input(z.object({ userId: uuid }))
-    .handler(async ({ input, context }) => context.users.get(input.userId)),
-
-  create: superadmin
-    .input(
-      z.object({
-        name: displayName,
-        email,
-        password,
-        role: instanceRole.default('editor'),
-      }),
-    )
-    .handler(async ({ input, context }) => context.users.create(input)),
-
-  update: superadmin
-    .input(z.object({ userId: uuid, name: displayName.optional(), email: email.optional() }))
-    .handler(async ({ input, context }) => {
-      const { userId, ...data } = input;
-      return context.users.update(userId, data);
-    }),
-
-  setRole: superadmin
-    .input(z.object({ userId: uuid, role: instanceRole }))
-    .handler(async ({ input, context }) => context.users.setRole(input.userId, input.role)),
-
-  /** Resets a password and signs the account out everywhere. */
-  setPassword: superadmin
-    .input(z.object({ userId: uuid, password }))
-    .handler(async ({ input, context }) => {
-      await context.users.setPassword(input.userId, input.password);
-      return { ok: true };
-    }),
-
-  ban: superadmin
-    .input(z.object({ userId: uuid, reason: z.string().trim().max(500).optional() }))
-    .handler(async ({ input, context }) =>
-      context.users.ban(context.principal.userId, input.userId, input.reason || null),
-    ),
-
-  unban: superadmin
-    .input(z.object({ userId: uuid }))
-    .handler(async ({ input, context }) => context.users.unban(input.userId)),
-
-  revokeSessions: superadmin
-    .input(z.object({ userId: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.users.revokeSessions(input.userId);
-      return { ok: true };
-    }),
-
-  delete: superadmin.input(z.object({ userId: uuid })).handler(async ({ input, context }) => {
-    await context.users.delete(context.principal.userId, input.userId);
-    return { ok: true };
-  }),
-
-  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(),
-        /**
-         * Grants the key is confined to, in the roles' vocabulary; omitted leaves the
-         * owner's role as the limit. At use the two are intersected, so a grant here
-         * never widens the key beyond its owner.
-         */
-        permissions: z.array(z.string().max(120)).max(500).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');
-      }
-      // A typed grant may name a type of any space the key will reach.
-      const reachable = input.spaceIds?.length
-        ? input.spaceIds
-        : context.principal.role === 'superadmin'
-          ? null
-          : Object.keys(context.principal.spaces);
-      const typeIds = new Set(
-        (reachable
-          ? reachable.flatMap((spaceId) => context.manablox.contentTypes.forSpace(spaceId))
-          : context.manablox.contentTypes.all
-        ).map((type) => type.id),
-      );
-      let permissions: string[] | null = null;
-      if (input.permissions) {
-        const checked = normaliseGrants(input.permissions, typeIds);
-        if (checked.unknown.length) {
-          throw ManabloxError.validation(
-            checked.unknown.map(({ index, grant }) => ({
-              key: 'role.permission.unknown' as const,
-              path: ['permissions', index],
-              params: { permission: grant },
-            })),
-            'apiKey.validation.failed',
-          );
-        }
-        permissions = checked.permissions;
-      }
-      return context.apiKeys.issue(context.principal.userId, input.name, {
-        expiresAt: input.expiresAt,
-        spaceIds: input.spaceIds,
-        permissions,
-      });
-    }),
-
-  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 };
-  }),
-};