@manablox/api-public 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,183 @@
+import { AssetCrop, FocalPoint, Manablox } from "@manablox/core";
+import { Loaders, MenuService } from "@manablox/services";
+import { z } from "zod";
+import { MediaService } from "@manablox/media";
+import { AssetRow, ContentRow, Repositories } from "@manablox/db";
+//#region src/context.d.ts
+/**
+ * The delivery context.
+ *
+ * Compare `RpcContext`: no `auth`, no `apiKeys`, no `principal`, no `content` service.
+ * A procedure here cannot authenticate a caller or write, because the context it runs
+ * in has nothing to do it with — the read-only guarantee is a property of the type, not
+ * a rule contributors have to remember.
+ */
+export interface PublicContext {
+  manablox: Manablox;
+  repos: Repositories;
+  media: MediaService;
+  menus: MenuService;
+  loaders: Loaders;
+  /** The one space this instance serves. Never taken from the request. */
+  spaceId: string;
+  locale: string;
+}
+//#endregion
+//#region src/serialize.d.ts
+export interface PublicAsset {
+  id: string;
+  url: string;
+  filename: string;
+  mimeType: string;
+  size: number;
+  width: number | null;
+  height: number | null;
+  alt: string | null;
+  title: string | null;
+  /**
+   * Where the subject is, as fractions of the (cropped) image, or `null` for centred.
+   * Variants already honour it; it is here for a frontend that renders the original
+   * itself, e.g. as CSS `object-position`.
+   */
+  focalPoint: FocalPoint | null;
+  /** The editor's crop in the original's pixels, or `null`. Variants are cut to it. */
+  crop: AssetCrop | null;
+  /**
+   * Signed transform URLs, keyed by preset name.
+   *
+   * The signature is an HMAC of the instance's media secret, so a client cannot mint
+   * one — an unsigned transform request is a resize amplifier and is refused. That is
+   * why the URLs are served rather than constructed in the SDK.
+   */
+  variants: Record<string, string>;
+}
+export interface PublicUser {
+  id: string;
+  name: string;
+  image: string | null;
+}
+export interface PublicContent {
+  id: string;
+  type: string;
+  title: string;
+  slug: string;
+  permalink: string | null;
+  locale: string;
+  parentId: string | null;
+  publishedAt: string | null;
+  updatedAt: string;
+  /**
+   * A plain map keyed by field name — `{ title, summary, components: [...] }`.
+   *
+   * GraphQL's per-type object is richer; REST's job is to be pleasant to consume with
+   * no schema knowledge, which a keyed map is and a tagged union is not.
+   */
+  fields: Record<string, unknown>;
+}
+export interface PublicBlock {
+  blockId: string;
+  type: string;
+  fields: Record<string, unknown>;
+}
+/** Which relation fields to inline rather than leave as ids. */
+export type ExpandSet = ReadonlySet<string>;
+export declare function parseExpand(raw: string | undefined): ExpandSet;
+/**
+ * Serialises rows for the REST surface.
+ *
+ * Three passes, not one: collect every id the expansion will need, load each target in
+ * a single batch, then build the output synchronously. Serialising and loading in one
+ * pass would still be correct — DataLoader batches within a tick — but it would depend
+ * on nothing in the walk ever awaiting, which is exactly the kind of invariant that
+ * quietly breaks and reintroduces the N+1 this whole layer exists to avoid.
+ */
+export declare function serializeContents(rows: ContentRow[], ctx: PublicContext, expand: ExpandSet): Promise<PublicContent[]>;
+export declare function serializeContent(row: ContentRow, ctx: PublicContext, expand: ExpandSet): Promise<PublicContent>;
+export declare function serializeAsset(asset: AssetRow, ctx: PublicContext): PublicAsset;
+//#endregion
+//#region src/router.d.ts
+/** A menu entry for REST: the document inlined, sub-entries nested. */
+interface PublicMenuEntry {
+  id: string;
+  label: string;
+  url: string | null;
+  content: PublicContent | null;
+  children: PublicMenuEntry[];
+}
+/**
+ * The public delivery API: one definition yielding REST, an OpenAPI document and the
+ * SDK's types. No `spaceId` appears anywhere — the space is pinned in the context.
+ */
+export declare const publicRouter: {
+  list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    under: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    expand: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    items: z.ZodArray<z.ZodType<PublicContent, unknown, z.core.$ZodTypeInternals<PublicContent, unknown>>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+  }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+  get: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodObject<{
+    id: z.ZodString;
+    expand: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodType<PublicContent, unknown, z.core.$ZodTypeInternals<PublicContent, unknown>>, Record<never, never>, Record<never, never>>;
+  byPermalink: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodObject<{
+    path: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodType<PublicContent, unknown, z.core.$ZodTypeInternals<PublicContent, unknown>>, Record<never, never>, Record<never, never>>;
+  home: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodObject<{
+    locale: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodType<PublicContent, unknown, z.core.$ZodTypeInternals<PublicContent, unknown>>, Record<never, never>, Record<never, never>>;
+  menu: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodObject<{
+    name: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    machineName: z.ZodString;
+    items: z.ZodArray<z.ZodType<PublicMenuEntry, unknown, z.core.$ZodTypeInternals<PublicMenuEntry, unknown>>>;
+  }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+  asset: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodObject<{
+    id: z.ZodString;
+  }, z.core.$strip>, z.ZodType<PublicAsset, unknown, z.core.$ZodTypeInternals<PublicAsset, unknown>>, Record<never, never>, Record<never, never>>;
+  types: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<PublicContext & Record<never, never>, PublicContext, PublicContext>, import("@orpc/server").MergedCurrentContext<PublicContext, Record<never, never>>, z.ZodOptional<z.ZodObject<{}, z.core.$strip>>, z.ZodObject<{
+    types: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      label: z.ZodString;
+      kind: z.ZodEnum<{
+        block: "block";
+        content: "content";
+      }>;
+      fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        list: z.ZodBoolean;
+        kind: z.ZodEnum<{
+          block: "block";
+          ref: "ref";
+          scalar: "scalar";
+        }>;
+        scalar: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodEnum<{
+          asset: "asset";
+          content: "content";
+          user: "user";
+        }>>;
+        blockTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+};
+export type PublicRouter = typeof publicRouter;
+//#endregion

package/dist/index.js

@@ -0,0 +1,424 @@
+import { ManabloxError, TRANSPORT_CODE, fieldBlocks, resolveGraphQL } from "@manablox/core";
+import { toPublicListQuery } from "@manablox/services";
+import { ORPCError, os } from "@orpc/server";
+import { z } from "zod";
+import { absoluteMediaUrl, readImageEdits } from "@manablox/media";
+//#region src/serialize.ts
+function parseExpand(raw) {
+	if (!raw) return /* @__PURE__ */ new Set();
+	return new Set(raw.split(",").map((name) => name.trim()).filter(Boolean));
+}
+/**
+* Serialises rows for the REST surface.
+*
+* Three passes, not one: collect every id the expansion will need, load each target in
+* a single batch, then build the output synchronously. Serialising and loading in one
+* pass would still be correct — DataLoader batches within a tick — but it would depend
+* on nothing in the walk ever awaiting, which is exactly the kind of invariant that
+* quietly breaks and reintroduces the N+1 this whole layer exists to avoid.
+*/
+async function serializeContents(rows, ctx, expand) {
+	const collected = {
+		content: /* @__PURE__ */ new Set(),
+		asset: /* @__PURE__ */ new Set(),
+		user: /* @__PURE__ */ new Set()
+	};
+	for (const row of rows) collectRow(row, ctx.manablox, expand, collected);
+	const resolved = await resolveAll(collected, ctx);
+	return rows.map((row) => buildContent(row, ctx, expand, resolved));
+}
+async function serializeContent(row, ctx, expand) {
+	const [only] = await serializeContents([row], ctx, expand);
+	return only;
+}
+function serializeAsset(asset, ctx) {
+	const base = ctx.manablox.config.server.publicUrl;
+	const edits = readImageEdits(asset.meta);
+	return {
+		id: asset.id,
+		url: absoluteMediaUrl(ctx.media.urlFor(asset), base),
+		variants: buildVariants(asset, ctx),
+		filename: asset.filename,
+		mimeType: asset.mimeType,
+		size: asset.size,
+		width: asset.width,
+		height: asset.height,
+		alt: asset.alt,
+		title: asset.title,
+		focalPoint: edits.focalPoint ?? null,
+		crop: edits.crop ?? null
+	};
+}
+/** Each configured preset, at the format the preset itself declares. */
+function buildVariants(asset, ctx) {
+	if (!asset.mimeType.startsWith("image/")) return {};
+	const presets = ctx.manablox.config.media.presets;
+	const base = ctx.manablox.config.server.publicUrl;
+	const out = {};
+	for (const [name, preset] of Object.entries(presets)) out[name] = absoluteMediaUrl(ctx.media.urlFor(asset, name, preset.format ?? "webp"), base);
+	return out;
+}
+function collectRow(row, manablox, expand, into) {
+	const type = manablox.contentTypes.tryGet(row.typeId);
+	if (!type) return;
+	collectFields(type, row.fields, manablox, expand, into, 0);
+}
+function collectFields(type, values, manablox, expand, into, depth) {
+	if (depth > 16) return;
+	for (const field of type.fields) {
+		if (field.readRoles?.length) continue;
+		const fieldType = manablox.fieldTypes.tryGet(field.type);
+		if (!fieldType) continue;
+		const value = values[field.name];
+		const spec = resolveGraphQL(fieldType, field.settings);
+		if (spec.type.kind === "ref" && expand.has(field.name)) for (const id of toIds(value)) into[spec.type.target].add(id);
+		if (fieldType.nested) for (const block of fieldBlocks(fieldType, value, field.settings)) {
+			const blockType = manablox.contentTypes.tryGet(block.type);
+			if (blockType) collectFields(blockType, block.fields, manablox, expand, into, depth + 1);
+		}
+	}
+}
+async function resolveAll(collected, ctx) {
+	const [contents, assets, users] = await Promise.all([
+		loadMany(ctx.loaders.publishedContent, collected.content),
+		loadMany(ctx.loaders.asset, collected.asset),
+		loadMany(ctx.loaders.user, collected.user)
+	]);
+	return {
+		content: contents,
+		asset: assets,
+		user: users
+	};
+}
+async function loadMany(loader, ids) {
+	if (ids.size === 0) return /* @__PURE__ */ new Map();
+	const rows = await loader.loadMany([...ids]);
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) if (row && !(row instanceof Error)) map.set(row.id, row);
+	return map;
+}
+function buildContent(row, ctx, expand, resolved) {
+	const type = ctx.manablox.contentTypes.tryGet(row.typeId);
+	return {
+		id: row.id,
+		type: type?.name ?? "unknown",
+		title: row.title,
+		slug: row.slug,
+		permalink: row.permalink,
+		locale: row.locale,
+		parentId: row.parentId,
+		publishedAt: row.publishedAt ? row.publishedAt.toISOString() : null,
+		updatedAt: row.updatedAt.toISOString(),
+		fields: type ? buildFields(type, row.fields, ctx, expand, resolved, 0) : {}
+	};
+}
+function buildFields(type, values, ctx, expand, resolved, depth) {
+	const out = {};
+	if (depth > 16) return out;
+	for (const field of type.fields) {
+		if (field.readRoles?.length) continue;
+		const fieldType = ctx.manablox.fieldTypes.tryGet(field.type);
+		if (!fieldType) continue;
+		const value = values[field.name];
+		const spec = resolveGraphQL(fieldType, field.settings);
+		if (fieldType.nested) {
+			const blocks = fieldBlocks(fieldType, value, field.settings).map((block) => {
+				const blockType = ctx.manablox.contentTypes.tryGet(block.type);
+				return {
+					blockId: block.blockId,
+					type: blockType?.name ?? "unknown",
+					fields: blockType ? buildFields(blockType, block.fields, ctx, expand, resolved, depth + 1) : {}
+				};
+			});
+			out[field.name] = spec.list === false ? blocks[0] ?? null : blocks;
+			continue;
+		}
+		if (spec.type.kind === "ref" && expand.has(field.name)) {
+			const inlined = toIds(value).map((id) => inline(spec.type.kind === "ref" ? spec.type.target : "content", id, ctx, resolved)).filter((entry) => entry !== null);
+			out[field.name] = spec.list ? inlined : inlined[0] ?? null;
+			continue;
+		}
+		out[field.name] = value ?? null;
+	}
+	return out;
+}
+function inline(target, id, ctx, resolved) {
+	if (target === "asset") {
+		const asset = resolved.asset.get(id);
+		return asset ? serializeAsset(asset, ctx) : null;
+	}
+	if (target === "user") {
+		const user = resolved.user.get(id);
+		return user ? {
+			id: user.id,
+			name: user.name,
+			image: user.image
+		} : null;
+	}
+	const row = resolved.content.get(id);
+	if (!row) return null;
+	return {
+		id: row.id,
+		type: ctx.manablox.contentTypes.tryGet(row.typeId)?.name ?? "unknown",
+		title: row.title,
+		permalink: row.permalink,
+		locale: row.locale
+	};
+}
+function toIds(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string");
+	return [];
+}
+//#endregion
+//#region src/router.ts
+/**
+* The base procedure.
+*
+* There is no `authed` and no `scoped` sibling here, and that is the point: a public
+* procedure has no principal to check, so the only middleware is the error mapping.
+*/
+const base = os.$context().use(async ({ next }) => {
+	try {
+		return await next();
+	} catch (error) {
+		if (!ManabloxError.is(error)) throw error;
+		throw new ORPCError(TRANSPORT_CODE[error.kind], {
+			message: error.key,
+			data: { key: error.key }
+		});
+	}
+});
+const uuid = z.string().uuid();
+const expandArg = z.string().max(200).optional().describe("Comma-separated relation fields to inline, e.g. `hero,author`.");
+const contentSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	title: z.string(),
+	slug: z.string(),
+	permalink: z.string().nullable(),
+	locale: z.string(),
+	parentId: z.string().nullable(),
+	publishedAt: z.string().nullable(),
+	updatedAt: z.string(),
+	fields: z.record(z.string(), z.unknown())
+});
+const assetSchema = z.object({
+	id: z.string(),
+	url: z.string(),
+	filename: z.string(),
+	mimeType: z.string(),
+	size: z.number(),
+	width: z.number().nullable(),
+	height: z.number().nullable(),
+	alt: z.string().nullable(),
+	title: z.string().nullable(),
+	focalPoint: z.object({
+		x: z.number(),
+		y: z.number()
+	}).nullable(),
+	crop: z.object({
+		left: z.number(),
+		top: z.number(),
+		width: z.number(),
+		height: z.number()
+	}).nullable(),
+	variants: z.record(z.string(), z.string())
+});
+const menuItemSchema = z.lazy(() => z.object({
+	id: z.string(),
+	label: z.string(),
+	url: z.string().nullable(),
+	content: contentSchema.nullable(),
+	children: z.array(menuItemSchema)
+}));
+const menuSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	machineName: z.string(),
+	items: z.array(menuItemSchema)
+});
+const listSchema = z.object({
+	items: z.array(contentSchema),
+	total: z.number(),
+	limit: z.number(),
+	offset: z.number()
+});
+/**
+* The public delivery API: one definition yielding REST, an OpenAPI document and the
+* SDK's types. No `spaceId` appears anywhere — the space is pinned in the context.
+*/
+const publicRouter = {
+	list: base.route({
+		method: "GET",
+		path: "/content",
+		summary: "List published documents",
+		tags: ["content"]
+	}).input(z.object({
+		type: z.string().max(100).optional(),
+		parentId: uuid.optional(),
+		under: uuid.optional(),
+		search: z.string().max(200).optional(),
+		locale: z.string().max(10).optional(),
+		limit: z.coerce.number().int().min(1).max(100).default(25),
+		offset: z.coerce.number().int().min(0).default(0),
+		expand: expandArg
+	})).output(listSchema).handler(async ({ input, context }) => {
+		const query = toPublicListQuery(context.manablox.contentTypes, input, {
+			spaceId: context.spaceId,
+			locale: context.locale
+		});
+		const page = await context.repos.content.list(query.filter, query.pagination, query.sorts, true);
+		return {
+			items: await serializeContents(page.items, context, parseExpand(input.expand)),
+			total: page.total,
+			limit: page.limit,
+			offset: page.offset
+		};
+	}),
+	get: base.route({
+		method: "GET",
+		path: "/content/{id}",
+		summary: "Fetch one published document by id",
+		tags: ["content"]
+	}).input(z.object({
+		id: uuid,
+		expand: expandArg
+	})).output(contentSchema).handler(async ({ input, context }) => {
+		const row = await context.loaders.publishedContent.load(input.id);
+		if (!row) throw ManabloxError.notFound("content.notFound", { id: input.id });
+		return serializeContent(row, context, parseExpand(input.expand));
+	}),
+	byPermalink: base.route({
+		method: "GET",
+		path: "/permalink/{+path}",
+		summary: "Resolve a URL path to a document",
+		tags: ["content"]
+	}).input(z.object({
+		path: z.string().max(2e3),
+		locale: z.string().max(10).optional(),
+		expand: expandArg
+	})).output(contentSchema).handler(({ input, context }) => resolvePermalink(input.path, input, context)),
+	home: base.route({
+		method: "GET",
+		path: "/permalink",
+		summary: "Resolve the space's home page",
+		tags: ["content"]
+	}).input(z.object({
+		locale: z.string().max(10).optional(),
+		expand: expandArg
+	})).output(contentSchema).handler(({ input, context }) => resolvePermalink("", input, context)),
+	menu: base.route({
+		method: "GET",
+		path: "/menus/{name}",
+		summary: "A navigation menu by name",
+		tags: ["content"]
+	}).input(z.object({
+		name: z.string().regex(/^[a-z][a-z0-9_-]*$/).max(64),
+		locale: z.string().max(10).optional(),
+		expand: expandArg
+	})).output(menuSchema).handler(async ({ input, context }) => {
+		const menu = await context.menus.resolve(context.spaceId, input.name, input.locale ?? context.locale, true);
+		if (!menu) throw ManabloxError.notFound("menu.notFound", { id: input.name });
+		const rows = collectMenuRows(menu.items);
+		const serialised = await serializeContents(rows, context, parseExpand(input.expand));
+		const byId = new Map(rows.map((row, index) => [row.id, serialised[index]]));
+		const toEntry = (item) => ({
+			id: item.id,
+			label: item.label,
+			url: item.url,
+			content: item.content ? byId.get(item.content.id) ?? null : null,
+			children: item.children.map(toEntry)
+		});
+		return {
+			id: menu.id,
+			name: menu.name,
+			machineName: menu.machineName,
+			items: menu.items.map(toEntry)
+		};
+	}),
+	asset: base.route({
+		method: "GET",
+		path: "/assets/{id}",
+		summary: "Fetch asset metadata",
+		tags: ["media"]
+	}).input(z.object({ id: uuid })).output(assetSchema).handler(async ({ input, context }) => {
+		const asset = await context.loaders.asset.load(input.id);
+		if (!asset) throw ManabloxError.notFound("asset.notFound", { id: input.id });
+		return serializeAsset(asset, context);
+	}),
+	types: base.route({
+		method: "GET",
+		path: "/types",
+		summary: "The space content model, for SDK type generation",
+		tags: ["schema"]
+	}).input(z.object({}).optional()).output(z.object({ types: z.array(z.object({
+		name: z.string(),
+		label: z.string(),
+		kind: z.enum(["content", "block"]),
+		fields: z.array(z.object({
+			name: z.string(),
+			type: z.string(),
+			required: z.boolean(),
+			list: z.boolean(),
+			/** `scalar` carries a GraphQL scalar name, `ref` a target, `block` neither. */
+			kind: z.enum([
+				"scalar",
+				"ref",
+				"block"
+			]),
+			scalar: z.string().optional(),
+			target: z.enum([
+				"content",
+				"asset",
+				"user"
+			]).optional(),
+			blockTypes: z.array(z.string()).optional()
+		}))
+	})) })).handler(({ context }) => {
+		const registry = context.manablox.contentTypes;
+		return { types: registry.all.filter((type) => type.spaceId === null || type.spaceId === context.spaceId).map((type) => ({
+			name: type.name,
+			label: type.label,
+			kind: type.kind,
+			fields: type.fields.filter((field) => !field.readRoles?.length).flatMap((field) => {
+				const fieldType = registry.fieldTypes.tryGet(field.type);
+				if (!fieldType) return [];
+				const spec = resolveGraphQL(fieldType, field.settings);
+				const blockTypes = blockTypeNames(context, field.settings);
+				return [{
+					name: field.name,
+					type: field.type,
+					required: field.required ?? false,
+					list: spec.list ?? false,
+					kind: spec.type.kind,
+					...spec.type.kind === "scalar" ? { scalar: spec.type.name } : {},
+					...spec.type.kind === "ref" ? { target: spec.type.target } : {},
+					...spec.type.kind === "block" && blockTypes ? { blockTypes } : {}
+				}];
+			})
+		})) };
+	})
+};
+/** A `blocks` field names its allowed types by id; the SDK needs their names. */
+function blockTypeNames(context, settings) {
+	const types = settings?.types;
+	if (!Array.isArray(types)) return void 0;
+	return types.filter((id) => typeof id === "string").map((id) => context.manablox.contentTypes.tryGet(id)?.name).filter((name) => Boolean(name));
+}
+function collectMenuRows(items) {
+	const out = [];
+	for (const item of items) {
+		if (item.content) out.push(item.content);
+		out.push(...collectMenuRows(item.children));
+	}
+	return out;
+}
+async function resolvePermalink(path, input, context) {
+	const permalink = path.replace(/^\/+|\/+$/g, "");
+	const row = await context.repos.content.findByPermalink(context.spaceId, input.locale ?? context.locale, permalink, true);
+	if (!row) throw ManabloxError.notFound("content.notFound", { permalink });
+	return serializeContent(row, context, parseExpand(input.expand));
+}
+//#endregion
+export { parseExpand, publicRouter, serializeAsset, serializeContent, serializeContents };

package/package.json

@@ -1,31 +1,38 @@
 {
   "name": "@manablox/api-public",
-  "version": "0.2.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/core": "0.2.0",
-    "@manablox/db": "0.2.0",
-    "@manablox/media": "0.2.0",
-    "@manablox/services": "0.2.0",
+    "@manablox/core": "0.3.0",
+    "@manablox/db": "0.3.0",
+    "@manablox/media": "0.3.0",
+    "@manablox/services": "0.3.0",
     "@orpc/server": "^1.15.0",
     "zod": "^4.5.4"
   },
   "devDependencies": {
     "@manablox/config-typescript": "0.0.0",
-    "@manablox/fields": "0.2.0",
+    "@manablox/fields": "0.3.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/context.ts

@@ -1,23 +0,0 @@
-import type { Manablox } from '@manablox/core';
-import type { Repositories } from '@manablox/db';
-import type { MediaService } from '@manablox/media';
-import type { Loaders, MenuService } from '@manablox/services';
-
-/**
- * The delivery context.
- *
- * Compare `RpcContext`: no `auth`, no `apiKeys`, no `principal`, no `content` service.
- * A procedure here cannot authenticate a caller or write, because the context it runs
- * in has nothing to do it with — the read-only guarantee is a property of the type, not
- * a rule contributors have to remember.
- */
-export interface PublicContext {
-  manablox: Manablox;
-  repos: Repositories;
-  media: MediaService;
-  menus: MenuService;
-  loaders: Loaders;
-  /** The one space this instance serves. Never taken from the request. */
-  spaceId: string;
-  locale: string;
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './context.js';
-export * from './router.js';
-export * from './serialize.js';