@manablox/api-rpc 0.2.0 → 0.4.0

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@manablox/api-rpc",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@manablox/auth": "0.2.0",
-    "@manablox/core": "0.2.0",
-    "@manablox/db": "0.2.0",
-    "@manablox/media": "0.2.0",
-    "@manablox/services": "0.2.0",
-    "@manablox/workflows": "0.2.0",
+    "@manablox/auth": "0.4.0",
+    "@manablox/core": "0.4.0",
+    "@manablox/db": "0.4.0",
+    "@manablox/media": "0.4.0",
+    "@manablox/services": "0.4.0",
+    "@manablox/workflows": "0.4.0",
     "@orpc/server": "^1.15.0",
     "@orpc/openapi": "^1.15.0",
     "zod": "^4.5.4"
@@ -24,10 +24,17 @@
   "devDependencies": {
     "@manablox/config-typescript": "0.0.0",
     "@types/node": "^26.4.1",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md"
+  ],
   "scripts": {
+    "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   }

package/src/base.ts

@@ -1,59 +0,0 @@
-import { assertCan, type Permission } from '@manablox/auth';
-import { ManabloxError, TRANSPORT_CODE } from '@manablox/core';
-import { ORPCError, os } from '@orpc/server';
-import type { RpcContext } from './context.js';
-
-/**
- * Base procedure builder. Every management procedure runs through it, so the
- * `ManabloxError` → transport mapping lives in exactly one place.
- */
-export const base = os.$context<RpcContext>().use(async ({ next }) => {
-  try {
-    return await next();
-  } catch (error) {
-    throw toOrpcError(error);
-  }
-});
-
-export function toOrpcError(error: unknown): unknown {
-  if (!ManabloxError.is(error)) return error;
-
-  return new ORPCError(TRANSPORT_CODE[error.kind], {
-    message: error.key,
-    // Structured details survive to the client: key, path and params per problem.
-    data: { key: error.key, details: error.details },
-  });
-}
-
-/** Requires an authenticated principal. */
-export const authed = base.use(async ({ context, next }) => {
-  if (!context.principal) throw toOrpcError(ManabloxError.unauthorized());
-  return next({ context: { ...context, principal: context.principal } });
-});
-
-/**
- * Requires a permission in the space named by the input's `spaceId`.
- *
- * Authorisation is a middleware rather than a call at the top of each handler, so a new
- * procedure cannot forget it — the input type makes `spaceId` mandatory.
- */
-export function scoped(permission: Permission) {
-  return authed.use(async ({ context, next }, input: unknown) => {
-    // The middleware sees the input before the schema runs, so a procedure whose space
-    // sits inside a `filter` object (the listings) is read there too.
-    const raw = input as { spaceId?: string; filter?: { spaceId?: string } } | undefined;
-    const spaceId = raw?.spaceId ?? raw?.filter?.spaceId ?? null;
-    assertCan(context.principal, spaceId, permission);
-    return next();
-  });
-}
-
-/** Requires an instance-wide superadmin, for operations that are not space-scoped. */
-export const superadmin = authed.use(async ({ context, next }) => {
-  // A space-restricted API key is confined to those spaces, so it never reaches an
-  // instance-wide operation even when its owner is a superadmin.
-  if (context.principal?.role !== 'superadmin' || context.principal.allowedSpaceIds) {
-    throw toOrpcError(ManabloxError.forbidden('auth.superadminRequired'));
-  }
-  return next();
-});

package/src/context.ts

@@ -1,70 +0,0 @@
-import type { ApiKeyService, ManabloxAuth, Principal, UserService } from '@manablox/auth';
-import type { Manablox } from '@manablox/core';
-import type { Repositories } from '@manablox/db';
-import type { MediaService } from '@manablox/media';
-import type {
-  ContentService,
-  ContentTypeService,
-  Loaders,
-  MenuService,
-  RoleService,
-  SpaceService,
-} from '@manablox/services';
-import type { WorkflowService } from '@manablox/workflows';
-
-/**
- * The part of the host's runtime the management procedures reach for. The host's own
- * `Runtime` extends this, so adding a service there and here is the whole change.
- */
-export interface RpcRuntime {
-  manablox: Manablox;
-  repos: Repositories;
-  auth: ManabloxAuth;
-  apiKeys: ApiKeyService;
-  media: MediaService;
-  content: ContentService;
-  contentTypes: ContentTypeService;
-  spaces: SpaceService;
-  users: UserService;
-  menus: MenuService;
-  roles: RoleService;
-  workflows: WorkflowService;
-}
-
-/** The runtime's RPC-facing slice, without whatever else the host keeps on it. */
-export function pickRpcRuntime(runtime: RpcRuntime): RpcRuntime {
-  const {
-    manablox,
-    repos,
-    auth,
-    apiKeys,
-    media,
-    content,
-    contentTypes,
-    spaces,
-    users,
-    menus,
-    roles,
-    workflows,
-  } = runtime;
-  return {
-    manablox,
-    repos,
-    auth,
-    apiKeys,
-    media,
-    content,
-    contentTypes,
-    spaces,
-    users,
-    menus,
-    roles,
-    workflows,
-  };
-}
-
-export interface RpcContext extends RpcRuntime {
-  loaders: Loaders;
-  principal: Principal | null;
-  headers: Headers;
-}

package/src/index.ts

@@ -1,28 +0,0 @@
-import { assetRouter } from './routers/asset.js';
-import { contentRouter } from './routers/content.js';
-import { contentTypeRouter } from './routers/content-type.js';
-import { menuRouter } from './routers/menu.js';
-import { roleRouter } from './routers/role.js';
-import { spaceRouter } from './routers/space.js';
-import { userRouter } from './routers/user.js';
-import { workflowRouter } from './routers/workflow.js';
-
-export * from './base.js';
-export * from './context.js';
-
-/**
- * The management API. The admin imports the *type* of this object and gets end-to-end
- * safety with no codegen step.
- */
-export const router = {
-  content: contentRouter,
-  contentTypes: contentTypeRouter,
-  spaces: spaceRouter,
-  assets: assetRouter,
-  users: userRouter,
-  menus: menuRouter,
-  roles: roleRouter,
-  workflows: workflowRouter,
-};
-
-export type ManabloxRouter = typeof router;

package/src/routers/asset.ts

@@ -1,96 +0,0 @@
-import { z } from 'zod';
-import { scoped } from '../base.js';
-import { pagination, searchTerm, uuid } from '../schemas.js';
-
-const crop = z.object({
-  left: z.number().int().min(0),
-  top: z.number().int().min(0),
-  width: z.number().int().min(1),
-  height: z.number().int().min(1),
-});
-const focalPoint = z.object({ x: z.number().min(0).max(1), y: z.number().min(0).max(1) });
-
-export const assetRouter = {
-  /** What an upload into this space is held to, and the instance's ceiling above it. */
-  limits: scoped('asset:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.media.limits(input.spaceId)),
-
-  list: scoped('asset:read')
-    .input(
-      pagination({ limit: 40, max: 100 }).extend({
-        spaceId: uuid,
-        mimeType: z.string().optional(),
-        search: searchTerm.optional(),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      const page = await context.repos.assets.list(
-        {
-          spaceId: input.spaceId,
-          ...(input.mimeType ? { mimeType: input.mimeType } : {}),
-          ...(input.search ? { search: input.search } : {}),
-        },
-        { limit: input.limit, offset: input.offset },
-      );
-      return { ...page, items: page.items.map((asset) => context.media.present(asset)) };
-    }),
-
-  /** Several assets in one round trip, for a field that references them; missing ids are absent. */
-  getMany: scoped('asset:read')
-    .input(z.object({ spaceId: uuid, ids: z.array(uuid).max(200) }))
-    .handler(async ({ input, context }) => {
-      const rows = await context.repos.assets.findManyByIds(input.ids, input.spaceId);
-      return rows.map((asset) => context.media.present(asset));
-    }),
-
-  get: scoped('asset:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      const asset = await context.repos.assets.findById(input.id);
-      return asset ? context.media.present(asset) : null;
-    }),
-
-  update: scoped('asset:write')
-    .input(
-      z.object({
-        spaceId: uuid,
-        id: uuid,
-        name: z.string().max(200).optional(),
-        alt: z.string().max(500).nullable().optional(),
-        title: z.string().max(500).nullable().optional(),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      const { spaceId: _spaceId, id, ...data } = input;
-      return context.repos.assets.update(id, data);
-    }),
-
-  /**
-   * An image's crop and focal point. `null` clears one; omitting it also clears it, so
-   * the call always states the whole edit. Every variant re-renders through the result.
-   */
-  setImageEdits: scoped('asset:write')
-    .input(
-      z.object({
-        spaceId: uuid,
-        id: uuid,
-        crop: crop.nullable().optional(),
-        focalPoint: focalPoint.nullable().optional(),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      const asset = await context.media.setImageEdits(input.id, {
-        crop: input.crop ?? null,
-        focalPoint: input.focalPoint ?? null,
-      });
-      return context.media.present(asset);
-    }),
-
-  delete: scoped('asset:delete')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.media.delete(input.id);
-      return { ok: true };
-    }),
-};

package/src/routers/content-type.ts

@@ -1,117 +0,0 @@
-import { renderContentTypeConfig } from '@manablox/services';
-import { z } from 'zod';
-import { base, scoped, superadmin } from '../base.js';
-import { uuid } from '../schemas.js';
-
-const fieldSchema = z.object({
-  id: z.string().optional(),
-  name: z.string().min(1).max(64),
-  label: z.string().optional(),
-  type: z.string(),
-  settings: z.record(z.string(), z.unknown()).default({}),
-  required: z.boolean().default(false),
-  localized: z.boolean().default(false),
-  unique: z.boolean().default(false),
-  readRoles: z.array(z.string()).optional(),
-  writeRoles: z.array(z.string()).optional(),
-  admin: z
-    .object({
-      zone: z.enum(['main', 'sidebar']).default('main'),
-      width: z.number().int().min(25).max(100).default(100),
-      position: z.number().int().default(0),
-      help: z.string().optional(),
-      placeholder: z.string().optional(),
-    })
-    .optional(),
-});
-
-const contentTypeSchema = z.object({
-  name: z.string().min(1).max(64),
-  label: z.string().optional(),
-  description: z.string().optional(),
-  icon: z.string().optional(),
-  kind: z.enum(['content', 'block']).default('content'),
-  spaceId: uuid.nullable().default(null),
-  hasSlug: z.boolean().optional(),
-  isPublishable: z.boolean().optional(),
-  isVisibleInTree: z.boolean().optional(),
-  canBeVisibleInMenu: z.boolean().optional(),
-  fields: z.array(fieldSchema).default([]),
-});
-
-export const contentTypeRouter = {
-  list: scoped('contentType:read')
-    .input(z.object({ spaceId: uuid }))
-    .handler(async ({ input, context }) => context.contentTypes.list(input.spaceId)),
-
-  get: scoped('contentType:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => context.contentTypes.get(input.id)),
-
-  create: scoped('contentType:write')
-    .input(contentTypeSchema.extend({ spaceId: uuid }))
-    .handler(async ({ input, context }) =>
-      context.contentTypes.create(input, context.principal.userId),
-    ),
-
-  update: scoped('contentType:write')
-    .input(contentTypeSchema.extend({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => context.contentTypes.update(input.id, input)),
-
-  delete: scoped('contentType:delete')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await context.contentTypes.delete(input.id);
-      return { ok: true };
-    }),
-
-  /**
-   * The field-type catalogue the admin's "add field" menu is built from. Derived from
-   * the registry, so a plugin's field type appears in the menu with no admin change.
-   */
-  fieldTypes: base.handler(async ({ context }) =>
-    context.manablox.fieldTypes.all.map((type) => ({
-      name: type.name,
-      label: type.label,
-      icon: type.icon ?? null,
-      description: type.description ?? null,
-      nested: type.nested ?? false,
-      filters: type.filters,
-      admin: type.admin,
-    })),
-  ),
-
-  /** JSON Schema for one field type's settings, so the admin renders its form generically. */
-  fieldTypeSettingsSchema: base
-    .input(z.object({ name: z.string() }))
-    .handler(async ({ input, context }) => {
-      const type = context.manablox.fieldTypes.get(input.name);
-      const schema = type.settingsSchema as unknown as { toJSONSchema?: () => unknown };
-      return {
-        name: type.name,
-        jsonSchema: typeof schema.toJSONSchema === 'function' ? schema.toJSONSchema() : null,
-      };
-    }),
-
-  /**
-   * The space's runtime types rendered as `manablox.config.ts` source, for moving a type
-   * built in the admin into code where it can be reviewed and versioned.
-   */
-  config: scoped('contentType:read')
-    .input(z.object({ spaceId: uuid, ids: z.array(uuid).optional() }))
-    .handler(async ({ input, context }) => {
-      const wanted = input.ids?.length ? new Set(input.ids) : null;
-      const types = context.manablox.contentTypes
-        .forSpace(input.spaceId)
-        // Code-defined types already live in a config file; re-emitting them would invite
-        // a second, diverging definition of the same type.
-        .filter((type) => type.source !== 'code' && (!wanted || wanted.has(type.id)));
-
-      return { code: renderContentTypeConfig(types), count: types.length };
-    }),
-
-  reload: superadmin.handler(async ({ context }) => {
-    await context.manablox.reload(await context.repos.contentTypes.all());
-    return { schemaVersion: context.manablox.contentTypes.schemaVersion };
-  }),
-};

package/src/routers/content.ts

@@ -1,266 +0,0 @@
-import { actorRoles, allowedTypeIds, assertCan, type ContentPermission } from '@manablox/auth';
-import { ManabloxError } from '@manablox/core';
-import { z } from 'zod';
-import { base, scoped, toOrpcError } from '../base.js';
-import type { RpcContext } from '../context.js';
-import { locale, pagination, searchTerm, uuid } from '../schemas.js';
-
-const filterSchema = z.object({
-  spaceId: uuid,
-  /** Specific documents, for a relation field's chips: one request instead of one per id. */
-  ids: z.array(uuid).max(200).optional(),
-  typeIds: z.array(uuid).optional(),
-  locale: locale.optional(),
-  status: z.enum(['draft', 'published', 'archived']).optional(),
-  parentId: uuid.nullable().optional(),
-  under: uuid.optional(),
-  search: searchTerm.optional(),
-  fields: z
-    .array(
-      z.object({
-        name: z.string(),
-        op: z.enum([
-          'eq',
-          'neq',
-          'lt',
-          'lte',
-          'gt',
-          'gte',
-          'in',
-          'notIn',
-          'contains',
-          'startsWith',
-          'endsWith',
-          'isNull',
-          'isNotNull',
-        ]),
-        value: z.unknown().optional(),
-      }),
-    )
-    .max(10)
-    .optional(),
-});
-
-const paginationSchema = pagination({ limit: 25, max: 200 });
-
-const sortSchema = z
-  .array(
-    z.object({
-      by: z.enum(['position', 'title', 'createdAt', 'updatedAt', 'publishedAt', 'slug']),
-      direction: z.enum(['asc', 'desc']).default('asc'),
-    }),
-  )
-  .max(3);
-
-const saveSchema = z.object({
-  spaceId: uuid,
-  typeId: uuid,
-  locale: locale.default('en'),
-  localizationId: uuid.optional(),
-  parentId: uuid.nullable().optional(),
-  title: z.string().min(1).max(500),
-  slug: z.string().max(200).optional(),
-  fields: z.record(z.string(), z.unknown()).default({}),
-  position: z.number().int().optional(),
-  expectedVersion: z.number().int().positive().optional(),
-});
-
-export const contentRouter = {
-  list: scoped('content:read')
-    .input(
-      z
-        .object({
-          filter: filterSchema,
-          pagination: paginationSchema.optional(),
-          sort: sortSchema.optional(),
-        })
-        .transform((v) => ({ ...v, spaceId: v.filter.spaceId })),
-    )
-    .handler(async ({ input, context }) => {
-      // A role that reads type by type sees only those types; asked for one it may not
-      // read, the answer is an empty page rather than a refusal.
-      const filter = narrowToAllowed(context, input.filter);
-      if (!filter) {
-        const pagination = input.pagination ?? { limit: 25, offset: 0 };
-        return { items: [], total: 0, ...pagination };
-      }
-      return context.content.list(
-        filter,
-        input.pagination ?? { limit: 25, offset: 0 },
-        input.sort ?? [],
-        { actor: toActor(context, input.filter.spaceId) },
-      );
-    }),
-
-  tree: scoped('content:read')
-    .input(
-      z.object({
-        spaceId: uuid,
-        locale: locale.default('en'),
-        rootId: uuid.nullable().default(null),
-      }),
-    )
-    .handler(async ({ input, context }) =>
-      context.content.tree(input.spaceId, input.locale, input.rootId),
-    ),
-
-  get: scoped('content:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:read', input.id);
-      return context.content.get(input.id, { actor: toActor(context, input.spaceId) });
-    }),
-
-  /** Field values with defaults filled in — what the editor opens a new document with. */
-  blank: scoped('content:read')
-    .input(z.object({ spaceId: uuid, typeId: uuid }))
-    .handler(async ({ input, context }) => {
-      assertOnType(context, input.spaceId, 'content:read', input.typeId);
-      return {
-        fields: await context.content.initFields(context.manablox.contentTypes.get(input.typeId)),
-      };
-    }),
-
-  create: scoped('content:write')
-    .input(saveSchema)
-    .handler(async ({ input, context }) => {
-      assertOnType(context, input.spaceId, 'content:write', input.typeId);
-      return context.content.create(input, toActor(context, input.spaceId));
-    }),
-
-  update: scoped('content:write')
-    .input(saveSchema.extend({ id: uuid }))
-    .handler(async ({ input, context }) => {
-      assertOnType(context, input.spaceId, 'content:write', input.typeId);
-      return context.content.update(input.id, input, toActor(context, input.spaceId));
-    }),
-
-  delete: scoped('content:delete')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:delete', input.id);
-      return { deleted: await context.content.delete(input.id, toActor(context, input.spaceId)) };
-    }),
-
-  publish: scoped('content:publish')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:publish', input.id);
-      return context.content.publish(input.id, toActor(context, input.spaceId));
-    }),
-
-  unpublish: scoped('content:publish')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:publish', input.id);
-      await context.content.unpublish(input.id, toActor(context, input.spaceId));
-      return { ok: true };
-    }),
-
-  /** Reparent or reorder a document in the tree — a drag in the admin's tree panel. */
-  move: scoped('content:write')
-    .input(
-      z.object({
-        spaceId: uuid,
-        id: uuid,
-        parentId: uuid.nullable(),
-        position: z.number().int().min(0),
-      }),
-    )
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:write', input.id);
-      return context.content.move(input.spaceId, input.id, input.parentId, input.position);
-    }),
-
-  /** Every locale a document exists in, for the editor's language switcher. */
-  translations: scoped('content:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => context.content.translations(input.spaceId, input.id)),
-
-  /** Starts a translation of an existing document, in the localization group it shares. */
-  createTranslation: scoped('content:write')
-    .input(z.object({ spaceId: uuid, id: uuid, locale }))
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:write', input.id);
-      return context.content.createTranslation(
-        input.spaceId,
-        input.id,
-        input.locale,
-        toActor(context, input.spaceId),
-      );
-    }),
-
-  versions: scoped('content:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => context.repos.content.versions(input.id)),
-
-  versionSnapshot: scoped('content:read')
-    .input(z.object({ spaceId: uuid, id: uuid, version: z.number().int().positive() }))
-    .handler(async ({ input, context }) =>
-      context.repos.content.versionSnapshot(input.id, input.version),
-    ),
-
-  restore: scoped('content:write')
-    .input(z.object({ spaceId: uuid, id: uuid, version: z.number().int().positive() }))
-    .handler(async ({ input, context }) => {
-      await assertOnDocument(context, input.spaceId, 'content:write', input.id);
-      return context.content.restore(input.id, input.version, toActor(context, input.spaceId));
-    }),
-};
-
-// ---------------------------------------------------------------------------
-// Per-type permissions
-//
-// `scoped('content:…')` admits anyone whose role holds the action for *some* type; which
-// type is only known once the input, or the document it names, is in hand. These finish
-// the check.
-// ---------------------------------------------------------------------------
-
-function assertOnType(
-  context: RpcContext,
-  spaceId: string,
-  permission: ContentPermission,
-  typeId: string,
-): void {
-  try {
-    assertCan(context.principal, spaceId, permission, typeId);
-  } catch (error) {
-    throw toOrpcError(error);
-  }
-}
-
-async function assertOnDocument(
-  context: RpcContext,
-  spaceId: string,
-  permission: ContentPermission,
-  id: string,
-): Promise<void> {
-  // Only when the role narrows the action: the common case costs no extra read.
-  if (allowedTypeIds(context.principal, spaceId, permission) === null) return;
-  const row = await context.repos.content.findById(id);
-  if (!row || row.spaceId !== spaceId) {
-    throw toOrpcError(ManabloxError.notFound('content.notFound', { id }));
-  }
-  assertOnType(context, spaceId, permission, row.typeId);
-}
-
-/** The filter narrowed to the types the caller may read; `null` when that leaves none. */
-function narrowToAllowed<T extends { spaceId: string; typeIds?: string[] | undefined }>(
-  context: RpcContext,
-  filter: T,
-): T | null {
-  const allowed = allowedTypeIds(context.principal, filter.spaceId, 'content:read');
-  if (allowed === null) return filter;
-  const typeIds = filter.typeIds?.length
-    ? filter.typeIds.filter((typeId) => allowed.includes(typeId))
-    : allowed;
-  return typeIds.length ? { ...filter, typeIds } : null;
-}
-
-export { base };
-
-function toActor(context: { principal: unknown }, spaceId: string) {
-  const principal = context.principal as { userId: string } | null;
-  if (!principal) return null;
-  return { userId: principal.userId, roles: actorRoles(principal as never, spaceId) };
-}