@manablox/api-rpc 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { MIN_PASSWORD_LENGTH, actorRoles, allowedTypeIds, assertCan, effectiveGrants, normaliseGrants } from "@manablox/auth";
-import { ManabloxError, TRANSPORT_CODE, WORKFLOW_CONDITION_OPERATORS, WORKFLOW_EVENTS } from "@manablox/core";
+import { MIN_PASSWORD_LENGTH, actorRoles, allowedTypeIds, assertCan, can, effectiveGrants, normaliseGrants } from "@manablox/auth";
+import { AUDIT_ACTIONS, ManabloxError, NOTIFICATION_CHANNELS, NOTIFICATION_KINDS, TRANSPORT_CODE, WORKFLOW_CONDITION_OPERATORS, WORKFLOW_EVENTS } from "@manablox/core";
 import { ORPCError, os } from "@orpc/server";
-import { renderContentTypeConfig } from "@manablox/services";
+import { SPACE_EXPORT_SECTIONS, applySpaceStarter, renderContentTypeConfig } from "@manablox/services";
 //#region src/base.ts
 /**
 * Base procedure builder. Every management procedure runs through it, so the
@@ -136,7 +136,7 @@ const assetRouter = {
 		title: z.string().max(500).nullable().optional()
 	})).handler(async ({ input, context }) => {
 		const { spaceId: _spaceId, id, ...data } = input;
-		return context.repos.assets.update(id, data);
+		return context.media.present(await context.media.update(id, data));
 	}),
 	/**
 	* An image's crop and focal point. `null` clears one; omitting it also clears it, so
@@ -163,6 +163,105 @@ const assetRouter = {
 	})
 };
 //#endregion
+//#region src/routers/audit.ts
+const actorKind = z.enum([
+	"user",
+	"apikey",
+	"workflow",
+	"system"
+]);
+const targetKind = z.enum([
+	"content",
+	"contentType",
+	"space",
+	"member",
+	"user",
+	"apiKey",
+	"menu",
+	"role",
+	"workflow",
+	"workflowRun",
+	"asset",
+	"session"
+]);
+const filterSchema$1 = z.object({
+	actorKind: actorKind.optional(),
+	actorId: z.string().max(200).optional(),
+	actions: z.array(z.enum(AUDIT_ACTIONS)).max(60).optional(),
+	targetKind: targetKind.optional(),
+	targetId: z.string().max(200).optional(),
+	from: z.coerce.date().optional(),
+	to: z.coerce.date().optional(),
+	search: searchTerm.optional()
+});
+const sortSchema$1 = z.object({
+	by: z.enum([
+		"at",
+		"action",
+		"actorLabel",
+		"targetKind",
+		"targetLabel"
+	]).default("at"),
+	direction: z.enum(["asc", "desc"]).default("desc")
+});
+const paginationSchema$1 = pagination({
+	limit: 50,
+	max: 200
+});
+/**
+* The activity log. Reading a space's log takes `audit:read` there; the instance-wide
+* view, which includes actions outside any space (accounts, keys, creating spaces), is a
+* superadmin's. Nothing here writes: the log is appended where the actions happen.
+*/
+const auditRouter = {
+	/** The actions, actor kinds and target kinds the filter can name. */
+	catalog: authed.handler(async ({ context }) => context.audit.catalog()),
+	list: scoped("audit:read").input(z.object({
+		spaceId: uuid,
+		filter: filterSchema$1.default({}),
+		sort: sortSchema$1.default({
+			by: "at",
+			direction: "desc"
+		}),
+		pagination: paginationSchema$1.default({
+			limit: 50,
+			offset: 0
+		})
+	})).handler(async ({ input, context }) => context.audit.list(input.spaceId, input.filter, input.sort, input.pagination)),
+	/**
+	* Every entry on the instance, or with `instanceOnly` just those outside any space.
+	* Superadmin, because it crosses spaces.
+	*/
+	listInstance: superadmin.input(z.object({
+		instanceOnly: z.boolean().default(false),
+		filter: filterSchema$1.default({}),
+		sort: sortSchema$1.default({
+			by: "at",
+			direction: "desc"
+		}),
+		pagination: paginationSchema$1.default({
+			limit: 50,
+			offset: 0
+		})
+	})).handler(async ({ input, context }) => context.audit.listInstance({
+		...input.filter,
+		...input.instanceOnly ? { spaceId: null } : {}
+	}, input.sort, input.pagination)),
+	get: scoped("audit:read").input(z.object({
+		spaceId: uuid,
+		id: uuid
+	})).handler(async ({ input, context }) => context.audit.get(input.spaceId, input.id)),
+	/** What has been recorded about one thing in the space: a document's history. */
+	forTarget: scoped("audit:read").input(z.object({
+		spaceId: uuid,
+		targetKind,
+		targetId: z.string().max(200),
+		limit: z.number().int().min(1).max(200).default(100)
+	})).handler(async ({ input, context }) => context.audit.forTarget(input.spaceId, input.targetKind, input.targetId, input.limit)),
+	/** Walks the whole chain and says whether every entry still hashes to what it claims. */
+	verify: superadmin.handler(async ({ context }) => context.audit.verify())
+};
+//#endregion
 //#region src/routers/content.ts
 const filterSchema = z.object({
 	spaceId: uuid,
@@ -202,6 +301,8 @@ const paginationSchema = pagination({
 	limit: 25,
 	max: 200
 });
+/** What an author says when asking, or a reviewer when answering. */
+const note = z.string().max(2e3);
 const sortSchema = z.array(z.object({
 	by: z.enum([
 		"position",
@@ -270,7 +371,10 @@ const contentRouter = {
 	}),
 	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));
+		const actor = toActor(context, input.spaceId);
+		const row = await context.content.create(input, actor);
+		if (context.manablox.contentTypes.get(row.typeId).requiresApproval && !input.localizationId && !can(context.principal, input.spaceId, "content:publish", row.typeId)) await context.approvals.request(input.spaceId, row.id, actor);
+		return row;
 	}),
 	update: scoped("content:write").input(saveSchema.extend({ id: uuid })).handler(async ({ input, context }) => {
 		assertOnType(context, input.spaceId, "content:write", input.typeId);
@@ -322,6 +426,49 @@ const contentRouter = {
 		await assertOnDocument(context, input.spaceId, "content:write", input.id);
 		return context.content.createTranslation(input.spaceId, input.id, input.locale, toActor(context, input.spaceId));
 	}),
+	/** Where a document stands in review: the open request, the last decision, the history. */
+	approval: 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.approvals.state(input.spaceId, input.id);
+	}),
+	/** The open requests the caller may decide on: those of the types they can publish. */
+	pendingApprovals: scoped("content:publish").input(z.object({ spaceId: uuid })).handler(async ({ input, context }) => context.approvals.pending(input.spaceId, allowedTypeIds(context.principal, input.spaceId, "content:publish"))),
+	requestApproval: scoped("content:write").input(z.object({
+		spaceId: uuid,
+		id: uuid,
+		note: note.optional()
+	})).handler(async ({ input, context }) => {
+		await assertOnDocument(context, input.spaceId, "content:write", input.id);
+		return context.approvals.request(input.spaceId, input.id, toActor(context, input.spaceId), input.note?.trim() || null);
+	}),
+	withdrawApproval: scoped("content:write").input(z.object({
+		spaceId: uuid,
+		id: uuid
+	})).handler(async ({ input, context }) => {
+		await assertOnDocument(context, input.spaceId, "content:write", input.id);
+		return context.approvals.withdraw(input.spaceId, input.id, toActor(context, input.spaceId));
+	}),
+	/** Approves and publishes; the requester is told. */
+	approve: scoped("content:publish").input(z.object({
+		spaceId: uuid,
+		id: uuid,
+		note: note.optional()
+	})).handler(async ({ input, context }) => {
+		await assertOnDocument(context, input.spaceId, "content:publish", input.id);
+		return context.approvals.approve(input.spaceId, input.id, toActor(context, input.spaceId), input.note?.trim() || null);
+	}),
+	/** Sends the document back with a note; the requester is told. */
+	reject: scoped("content:publish").input(z.object({
+		spaceId: uuid,
+		id: uuid,
+		note: note.optional()
+	})).handler(async ({ input, context }) => {
+		await assertOnDocument(context, input.spaceId, "content:publish", input.id);
+		return context.approvals.reject(input.spaceId, input.id, toActor(context, input.spaceId), input.note?.trim() || null);
+	}),
 	versions: scoped("content:read").input(z.object({
 		spaceId: uuid,
 		id: uuid
@@ -403,6 +550,7 @@ const contentTypeSchema = z.object({
 	isPublishable: z.boolean().optional(),
 	isVisibleInTree: z.boolean().optional(),
 	canBeVisibleInMenu: z.boolean().optional(),
+	requiresApproval: z.boolean().optional(),
 	fields: z.array(fieldSchema).default([])
 });
 const contentTypeRouter = {
@@ -519,6 +667,51 @@ const menuRouter = {
 	})).handler(async ({ input, context }) => context.menus.usedIn(input.spaceId, input.localizationId))
 };
 //#endregion
+//#region src/routers/notification.ts
+const kind = z.enum(NOTIFICATION_KINDS);
+const ids = z.array(uuid).min(1).max(200);
+/**
+* Each kind's channels, every one optional: absent means the default. A partial record,
+* so a kind not named keeps its default; strict objects, so a misspelt channel is an
+* error rather than a silently dropped choice.
+*/
+const preferencesSchema = z.partialRecord(kind, z.strictObject(Object.fromEntries(NOTIFICATION_CHANNELS.map((channel) => [channel, z.boolean().optional()]))));
+/**
+* The caller's own inbox and preferences. Nothing here takes a `userId`: every
+* procedure acts as the signed-in account, so there is no way to read or change what
+* belongs to someone else.
+*/
+const notificationRouter = {
+	/** The kinds, the channels, and which channels this instance can actually send on. */
+	catalog: authed.handler(async ({ context }) => context.notifications.catalog()),
+	list: authed.input(z.object({
+		unreadOnly: z.boolean().default(false),
+		kinds: z.array(kind).optional(),
+		/** A space's notifications, `null` for instance-wide ones, absent for all. */
+		spaceId: uuid.nullable().optional(),
+		pagination: pagination({
+			limit: 25,
+			max: 100
+		}).optional()
+	}).default({ unreadOnly: false })).handler(async ({ input, context }) => context.notifications.list(context.principal.userId, {
+		unreadOnly: input.unreadOnly,
+		kinds: input.kinds,
+		spaceId: input.spaceId
+	}, input.pagination ?? {
+		limit: 25,
+		offset: 0
+	})),
+	unreadCount: authed.handler(async ({ context }) => ({ count: await context.notifications.unreadCount(context.principal.userId) })),
+	markRead: authed.input(z.object({ ids })).handler(async ({ input, context }) => ({ changed: await context.notifications.markRead(context.principal.userId, input.ids) })),
+	markUnread: authed.input(z.object({ ids })).handler(async ({ input, context }) => ({ changed: await context.notifications.markUnread(context.principal.userId, input.ids) })),
+	markAllRead: authed.handler(async ({ context }) => ({ changed: await context.notifications.markAllRead(context.principal.userId) })),
+	delete: authed.input(z.object({ ids })).handler(async ({ input, context }) => ({ deleted: await context.notifications.delete(context.principal.userId, input.ids) })),
+	deleteRead: authed.handler(async ({ context }) => ({ deleted: await context.notifications.deleteRead(context.principal.userId) })),
+	/** Every kind with the caller's effective choice per channel, defaults filled in. */
+	preferences: authed.handler(async ({ context }) => context.notifications.preferences(context.principal.userId)),
+	setPreferences: authed.input(z.object({ preferences: preferencesSchema })).handler(async ({ input, context }) => context.notifications.setPreferences(context.principal.userId, input.preferences))
+};
+//#endregion
 //#region src/routers/role.ts
 const roleSchema = z.object({
 	spaceId: uuid,
@@ -559,6 +752,8 @@ const roleRouter = {
 };
 //#endregion
 //#region src/routers/space.ts
+/** The parts of a space an export carries or an import restores; all of them when absent. */
+const exportSections = z.array(z.enum(SPACE_EXPORT_SECTIONS)).min(1);
 const spaceSchema = z.object({
 	name: z.string().min(1).max(200),
 	machineName,
@@ -586,7 +781,21 @@ const spaceRouter = {
 		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)),
+	/**
+	* `starter` fills the new space with the basic setup, a content model, a few
+	* published pages and a main menu, so the first thing its owner sees is a site rather
+	* than an empty tree. See `applySpaceStarter`.
+	*/
+	create: superadmin.input(spaceSchema.extend({ starter: z.boolean().default(false) })).handler(async ({ input, context }) => {
+		const { starter, ...data } = input;
+		const { principal } = context;
+		const space = await context.spaces.create(data, principal.userId);
+		if (starter) await applySpaceStarter(context, space, {
+			userId: principal.userId,
+			roles: actorRoles(principal, space.id)
+		});
+		return space;
+	}),
 	update: scoped("space:write").input(spaceSchema.partial().extend({ spaceId: uuid })).handler(async ({ input, context }) => {
 		const { spaceId, ...data } = input;
 		return context.spaces.update(spaceId, data);
@@ -617,9 +826,15 @@ const spaceRouter = {
 	* 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)),
+	export: scoped("space:write").input(z.object({
+		spaceId: uuid,
+		sections: exportSections.optional()
+	})).handler(async ({ input, context }) => context.spaces.export(input.spaceId, input.sections)),
 	/** 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)),
+	import: superadmin.input(z.object({
+		payload: z.unknown(),
+		sections: exportSections.optional()
+	})).handler(async ({ input, context }) => context.spaces.import(input.payload, context.principal.userId, input.sections)),
 	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,
@@ -730,6 +945,19 @@ const userRouter = {
 		await context.users.delete(context.principal.userId, input.userId);
 		return { ok: true };
 	}),
+	/** The caller's own profile: name and email. The instance role is not theirs to set. */
+	updateProfile: authed.input(z.object({
+		name: displayName.optional(),
+		email: email.optional()
+	})).handler(async ({ input, context }) => context.users.update(context.principal.userId, input)),
+	/** A new password for the caller, given the current one. Other sessions stay signed in. */
+	changePassword: authed.input(z.object({
+		currentPassword: z.string().min(1).max(200),
+		password
+	})).handler(async ({ input, context }) => {
+		await context.users.changePassword(context.principal.userId, input.currentPassword, input.password);
+		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),
@@ -958,7 +1186,7 @@ const workflowRouter = {
 //#region src/context.ts
 /** The runtime's RPC-facing slice, without whatever else the host keeps on it. */
 function pickRpcRuntime(runtime) {
-	const { manablox, repos, auth, apiKeys, media, content, contentTypes, spaces, users, menus, roles, workflows } = runtime;
+	const { manablox, repos, auth, apiKeys, media, content, contentTypes, spaces, users, menus, roles, workflows, audit, notifications, approvals } = runtime;
 	return {
 		manablox,
 		repos,
@@ -971,7 +1199,10 @@ function pickRpcRuntime(runtime) {
 		users,
 		menus,
 		roles,
-		workflows
+		workflows,
+		audit,
+		notifications,
+		approvals
 	};
 }
 //#endregion
@@ -988,7 +1219,9 @@ const router = {
 	users: userRouter,
 	menus: menuRouter,
 	roles: roleRouter,
-	workflows: workflowRouter
+	workflows: workflowRouter,
+	audit: auditRouter,
+	notifications: notificationRouter
 };
 //#endregion
 export { authed, base, pickRpcRuntime, router, scoped, superadmin, toOrpcError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manablox/api-rpc",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {
@@ -11,12 +11,12 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@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",
+    "@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"