@manablox/api-rpc 0.1.0 → 0.3.0

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@manablox/api-rpc",
-  "version": "0.1.0",
+  "version": "0.3.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.1.0",
-    "@manablox/core": "0.1.0",
-    "@manablox/db": "0.1.0",
-    "@manablox/media": "0.1.0",
-    "@manablox/services": "0.1.0",
+    "@manablox/auth": "0.3.0",
+    "@manablox/core": "0.3.0",
+    "@manablox/db": "0.3.0",
+    "@manablox/media": "0.3.0",
+    "@manablox/services": "0.3.0",
+    "@manablox/workflows": "0.3.0",
     "@orpc/server": "^1.15.0",
     "@orpc/openapi": "^1.15.0",
     "zod": "^4.5.4"
@@ -23,10 +24,18 @@
   "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": {
-    "typecheck": "tsc --noEmit"
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
 }

package/src/base.ts

@@ -1,68 +0,0 @@
-import { assertCan, type Permission } from '@manablox/auth';
-import { ManabloxError } 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;
-
-  const code = (
-    {
-      validation: 'BAD_REQUEST',
-      bad_request: 'BAD_REQUEST',
-      not_found: 'NOT_FOUND',
-      conflict: 'CONFLICT',
-      forbidden: 'FORBIDDEN',
-      unauthorized: 'UNAUTHORIZED',
-      internal: 'INTERNAL_SERVER_ERROR',
-    } as const
-  )[error.kind];
-
-  return new ORPCError(code, {
-    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) => {
-    const spaceId = (input as { spaceId?: string } | undefined)?.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,18 +0,0 @@
-import type { ApiKeyService, ManabloxAuth, Principal } 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 } from '@manablox/services';
-
-export interface RpcContext {
-  manablox: Manablox;
-  repos: Repositories;
-  auth: ManabloxAuth;
-  apiKeys: ApiKeyService;
-  media: MediaService;
-  content: ContentService;
-  contentTypes: ContentTypeService;
-  loaders: Loaders;
-  principal: Principal | null;
-  headers: Headers;
-}

package/src/index.ts

@@ -1,22 +0,0 @@
-import { assetRouter } from './routers/asset.js';
-import { contentRouter } from './routers/content.js';
-import { contentTypeRouter } from './routers/content-type.js';
-import { spaceRouter } from './routers/space.js';
-import { userRouter } from './routers/user.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,
-};
-
-export type ManabloxRouter = typeof router;

package/src/routers/asset.ts

@@ -1,67 +0,0 @@
-import { z } from 'zod';
-import { scoped } from '../base.js';
-
-const uuid = z.string().uuid();
-
-export const assetRouter = {
-  list: scoped('asset:read')
-    .input(
-      z.object({
-        spaceId: uuid,
-        mimeType: z.string().optional(),
-        search: z.string().max(200).optional(),
-        limit: z.number().int().min(1).max(100).default(40),
-        offset: z.number().int().min(0).default(0),
-      }),
-    )
-    .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) => ({
-          ...asset,
-          url: context.media.urlFor(asset),
-          thumbnailUrl: asset.mimeType.startsWith('image/')
-            ? context.media.urlFor(asset, 'thumb', 'webp')
-            : null,
-        })),
-      };
-    }),
-
-  get: scoped('asset:read')
-    .input(z.object({ spaceId: uuid, id: uuid }))
-    .handler(async ({ input, context }) => {
-      const asset = await context.repos.assets.findById(input.id);
-      if (!asset) return null;
-      return { ...asset, url: context.media.urlFor(asset) };
-    }),
-
-  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);
-    }),
-
-  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,116 +0,0 @@
-import { renderContentTypeConfig } from '@manablox/services';
-import { z } from 'zod';
-import { base, scoped, superadmin } from '../base.js';
-
-const uuid = z.string().uuid();
-
-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)),
-
-  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,200 +0,0 @@
-import { actorRoles } from '@manablox/auth';
-import { z } from 'zod';
-import { base, scoped } from '../base.js';
-
-const uuid = z.string().uuid();
-
-const filterSchema = z.object({
-  spaceId: uuid,
-  typeIds: z.array(uuid).optional(),
-  locale: z.string().optional(),
-  status: z.enum(['draft', 'published', 'archived']).optional(),
-  parentId: uuid.nullable().optional(),
-  under: uuid.optional(),
-  search: z.string().max(200).optional(),
-  visibleInMenu: z.boolean().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 = z.object({
-  limit: z.number().int().min(1).max(200).default(25),
-  offset: z.number().int().min(0).default(0),
-});
-
-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: z.string().min(2).max(10).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({}),
-  visibleInMenu: z.boolean().optional(),
-  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 }) =>
-      context.content.list(
-        input.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: z.string().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 }) =>
-      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 }) => ({
-      fields: await context.content.initFields(context.manablox.contentTypes.get(input.typeId)),
-    })),
-
-  create: scoped('content:write')
-    .input(saveSchema)
-    .handler(async ({ input, context }) =>
-      context.content.create(input, toActor(context, input.spaceId)),
-    ),
-
-  update: scoped('content:write')
-    .input(saveSchema.extend({ id: uuid }))
-    .handler(async ({ input, context }) =>
-      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 }) => ({
-      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 }) =>
-      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 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 }) =>
-      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: z.string().min(2).max(10) }))
-    .handler(async ({ input, context }) =>
-      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 }) =>
-      context.content.restore(input.id, input.version, toActor(context, input.spaceId)),
-    ),
-};
-
-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) };
-}