@mx-space/byline-api-client 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,566 @@
+//#region src/case.ts
+const isPlainObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const camelcase = (key) => key.replaceAll(/_([\da-z])/gi, (_, char) => char.toUpperCase());
+const splitPath = (path) => path.replaceAll("[]", ".[]").split(".").filter((segment) => segment.length > 0);
+const buildTree = (paths) => {
+	const root = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const segments = splitPath(path);
+		let node = root;
+		segments.forEach((segment, index) => {
+			if (index === segments.length - 1) {
+				node.set(segment, true);
+				return;
+			}
+			const next = node.get(segment);
+			if (next === true) return;
+			const child = next ?? /* @__PURE__ */ new Map();
+			node.set(segment, child);
+			node = child;
+		});
+	}
+	return root;
+};
+const walk = (value, tree) => {
+	if (Array.isArray(value)) {
+		const element = tree?.get("[]");
+		if (element === true) return value;
+		return value.map((item) => walk(item, element));
+	}
+	if (!isPlainObject(value)) return value;
+	const out = {};
+	for (const [key, item] of Object.entries(value)) {
+		const nextKey = camelcase(key);
+		const branch = tree?.get(nextKey);
+		out[nextKey] = branch === true ? item : walk(item, branch);
+	}
+	return out;
+};
+const camelcaseKeys = (value, preservePaths = []) => walk(value, buildTree(preservePaths));
+//#endregion
+//#region src/error.ts
+var BylineApiError = class extends Error {
+	status;
+	code;
+	path;
+	details;
+	name = "BylineApiError";
+	constructor(status, code, message, path, details) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.path = path;
+		this.details = details;
+	}
+};
+const isBylineApiError = (error, code) => error instanceof BylineApiError && (code === void 0 || error.code === code);
+//#endregion
+//#region src/http.ts
+const ENVELOPE_KEYS = /* @__PURE__ */ new Set(["data", "meta"]);
+const isEnvelope = (body) => !!body && typeof body === "object" && !Array.isArray(body) && "data" in body && Object.keys(body).every((key) => ENVELOPE_KEYS.has(key));
+const isBinaryBody = (body) => typeof FormData !== "undefined" && body instanceof FormData || typeof Blob !== "undefined" && body instanceof Blob || body instanceof ArrayBuffer || body instanceof URLSearchParams || typeof body === "string";
+var HttpCore = class {
+	options;
+	endpoint;
+	fetchImpl;
+	constructor(options) {
+		this.options = options;
+		if (!options.endpoint) throw new TypeError("endpoint is required");
+		this.endpoint = options.endpoint.replace(/\/+$/, "");
+		const fetchImpl = options.fetch ?? globalThis.fetch;
+		if (!fetchImpl) throw new TypeError("No fetch implementation available");
+		this.fetchImpl = fetchImpl;
+	}
+	get lang() {
+		return this.options.lang;
+	}
+	buildUrl(path, query) {
+		const url = new URL(`${this.endpoint}/${path.replace(/^\/+/, "")}`);
+		for (const [key, value] of Object.entries(query ?? {})) {
+			if (value === void 0 || value === null) continue;
+			url.searchParams.set(key, Array.isArray(value) ? value.join(",") : String(value));
+		}
+		return url.toString();
+	}
+	async request(method, path, options = {}) {
+		const headers = {
+			accept: "application/json",
+			...this.options.headers,
+			...options.headers
+		};
+		if (this.options.apiKey) headers["x-api-key"] = this.options.apiKey;
+		if (this.options.token) headers.authorization = `Bearer ${this.options.token}`;
+		let body;
+		if (options.body !== void 0) {
+			if (isBinaryBody(options.body)) body = options.body;
+			else {
+				headers["content-type"] = "application/json";
+				body = JSON.stringify(options.body);
+			}
+		}
+		const url = this.buildUrl(path, options.query);
+		const response = await this.fetchImpl(url, {
+			method,
+			headers,
+			body,
+			signal: options.signal
+		});
+		if (response.status === 204) return { data: void 0 };
+		const payload = (response.headers.get("content-type") ?? "").includes("json") ? await response.json().catch(() => null) : await response.text();
+		if (!response.ok) throw this.toError(response.status, path, payload);
+		if (!isEnvelope(payload)) return { data: this.transform(payload, options.preserve) };
+		return {
+			data: this.transform(payload.data, options.preserve),
+			...payload.meta === void 0 ? {} : { meta: this.transform(payload.meta) }
+		};
+	}
+	transform(value, preserve) {
+		if (this.options.camelCase === false) return value;
+		return camelcaseKeys(value, preserve);
+	}
+	toError(status, path, payload) {
+		const error = payload && typeof payload === "object" && "error" in payload ? payload.error : void 0;
+		if (error && typeof error === "object") return new BylineApiError(status, String(error.code ?? "HTTP_ERROR"), String(error.message ?? `Request failed with status ${status}`), path, error.details === void 0 ? void 0 : camelcaseKeys(error.details));
+		return new BylineApiError(status, "HTTP_ERROR", typeof payload === "string" && payload ? payload.slice(0, 500) : `Request failed with status ${status}`, path);
+	}
+};
+//#endregion
+//#region src/resources/authors.ts
+var AuthorsResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	list(query = {}) {
+		return this.http.request("GET", "/authors", { query: { ...query } });
+	}
+	async listAll() {
+		const authors = [];
+		for (let page = 1;; page++) {
+			const { data, meta } = await this.list({
+				page,
+				size: 100
+			});
+			authors.push(...data);
+			if (!meta || page >= meta.pagination.totalPages || !data.length) break;
+		}
+		return authors;
+	}
+	get(idOrUsername) {
+		return this.http.request("GET", `/authors/${encodeURIComponent(idOrUsername)}`);
+	}
+};
+//#endregion
+//#region src/resources/content.ts
+const CATALOG_PRESERVE = ["components[].propsSchema"];
+var CategoriesResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	list(options = {}) {
+		return this.http.request("GET", "/categories", { query: { lang: options.lang ?? this.http.lang } });
+	}
+	get(slugOrId, options = {}) {
+		return this.http.request("GET", `/categories/${encodeURIComponent(slugOrId)}`, { query: { lang: options.lang ?? this.http.lang } });
+	}
+	create(input) {
+		return this.http.request("POST", "/categories", { body: input });
+	}
+	update(id, input) {
+		return this.http.request("PATCH", `/categories/${id}`, { body: input });
+	}
+	delete(id) {
+		return this.http.request("DELETE", `/categories/${id}`);
+	}
+};
+var TranslationsResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	getForArticle(articleId, lang) {
+		return this.http.request("GET", `/ai/translations/article/${articleId}`, { query: { lang } });
+	}
+	languages(articleId) {
+		return this.http.request("GET", `/ai/translations/article/${articleId}/languages`);
+	}
+	listByRef(articleId) {
+		return this.http.request("GET", `/ai/translations/ref/${articleId}`, { preserve: ["article.document.meta"] });
+	}
+	writeManual(articleId, lang, input) {
+		return this.http.request("PUT", `/ai/translations/article/${articleId}/${encodeURIComponent(lang)}`, { body: {
+			...input,
+			content: typeof input.content === "string" ? input.content : JSON.stringify(input.content)
+		} });
+	}
+	update(id, patch) {
+		return this.http.request("PATCH", `/ai/translations/${id}`, { body: patch });
+	}
+	delete(id) {
+		return this.http.request("DELETE", `/ai/translations/${id}`);
+	}
+	createTask(input) {
+		return this.http.request("POST", "/ai/translations/task", { body: input });
+	}
+};
+var DynamicComponentsResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	list() {
+		return this.http.request("GET", "/dynamic-components", { preserve: CATALOG_PRESERVE });
+	}
+	register(input) {
+		return this.http.request("POST", "/dynamic-components", {
+			body: input,
+			preserve: CATALOG_PRESERVE
+		});
+	}
+};
+var FilesResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	upload(file, options = {}) {
+		const form = new FormData();
+		const filename = options.filename ?? (typeof File !== "undefined" && file instanceof File ? file.name : "upload.bin");
+		form.append("file", file, filename);
+		return this.http.request("POST", "/files/upload", {
+			query: {
+				type: options.type,
+				immutable: options.immutable ? "true" : void 0
+			},
+			body: form
+		});
+	}
+};
+//#endregion
+//#region src/resources/drafts.ts
+var DraftsResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	list(query = {}) {
+		return this.http.request("GET", "/drafts", { query });
+	}
+	get(id) {
+		return this.http.request("GET", `/drafts/${id}`);
+	}
+	context(refType, refId) {
+		return this.http.request("GET", `/drafts/context/${refType}/${refId}`);
+	}
+	create(input) {
+		return this.http.request("POST", "/drafts", { body: input });
+	}
+	update(id, input) {
+		return this.http.request("PUT", `/drafts/${id}`, { body: input });
+	}
+	delete(id) {
+		return this.http.request("DELETE", `/drafts/${id}`);
+	}
+};
+//#endregion
+//#region src/resources/posts.ts
+const POST_PRESERVE = ["meta"];
+const POST_LIST_PRESERVE = ["[].meta"];
+const DRAFT_CORE_KEYS = /* @__PURE__ */ new Set([
+	"title",
+	"text",
+	"content",
+	"images",
+	"meta"
+]);
+const toDraftData = (input) => {
+	const data = { contentFormat: "lexical" };
+	const typeSpecificData = {};
+	for (const [key, value] of Object.entries(input)) {
+		if (value === void 0) continue;
+		if (key === "content") data.content = typeof value === "string" ? value : JSON.stringify(value);
+		else if (DRAFT_CORE_KEYS.has(key)) data[key] = value;
+		else typeSpecificData[key] = value;
+	}
+	if (data.content !== void 0 && data.text === void 0) data.text = "";
+	if (Object.keys(typeSpecificData).length > 0) data.typeSpecificData = typeSpecificData;
+	return data;
+};
+const mergeSnapshot = (base, patch) => ({
+	title: base.title,
+	text: base.text,
+	content: base.content ?? void 0,
+	images: base.images,
+	meta: base.meta,
+	...patch,
+	contentFormat: "lexical",
+	typeSpecificData: {
+		...base.typeSpecificData,
+		...patch.typeSpecificData
+	}
+});
+var PostsResource = class {
+	http;
+	drafts;
+	publishJobs;
+	constructor(http, drafts, publishJobs) {
+		this.http = http;
+		this.drafts = drafts;
+		this.publishJobs = publishJobs;
+	}
+	list(query = {}) {
+		return this.http.request("GET", "/posts", {
+			query: {
+				...query,
+				lang: query.lang ?? this.http.lang
+			},
+			preserve: POST_LIST_PRESERVE
+		});
+	}
+	get(id, options = {}) {
+		return this.http.request("GET", `/posts/${id}`, {
+			query: { lang: options.lang ?? this.http.lang },
+			preserve: POST_PRESERVE
+		});
+	}
+	getBySlug(categorySlug, slug, options = {}) {
+		return this.http.request("GET", `/posts/${encodeURIComponent(categorySlug)}/${encodeURIComponent(slug)}`, {
+			query: { lang: options.lang ?? this.http.lang },
+			preserve: POST_PRESERVE
+		});
+	}
+	getPath(slug) {
+		return this.http.request("GET", `/posts/get-url/${encodeURIComponent(slug)}`);
+	}
+	async findBySlug(slug, options = {}) {
+		try {
+			const { data } = await this.getPath(slug);
+			const [category, postSlug] = data.path.replace(/^\/+/, "").split("/");
+			if (!category || !postSlug) return null;
+			return await this.getBySlug(category, decodeURIComponent(postSlug), options);
+		} catch (error) {
+			if (isBylineApiError(error) && error.status === 404) return null;
+			throw error;
+		}
+	}
+	latest(options = {}) {
+		return this.http.request("GET", "/posts/latest", {
+			query: { lang: options.lang ?? this.http.lang },
+			preserve: POST_PRESERVE
+		});
+	}
+	update(id, patch) {
+		return this.http.request("PATCH", `/posts/${id}`, { body: patch });
+	}
+	setPublished(id, isPublished) {
+		return this.http.request("PATCH", `/posts/${id}/publish`, { body: { isPublished } });
+	}
+	delete(id) {
+		return this.http.request("DELETE", `/posts/${id}`);
+	}
+	async create(input, options = {}) {
+		const { data: draft } = await this.drafts.create({
+			refType: "post",
+			data: toDraftData(input)
+		});
+		return this.finish(draft, options);
+	}
+	async revise(id, input, options = {}) {
+		const { data: context } = await this.drafts.context("post", id);
+		const base = context.publishedRevision;
+		if (!base) throw new BylineApiError(404, "CONTENT_REVISION_NOT_FOUND", `Post ${id} has no published revision to branch from`, `/drafts/context/post/${id}`);
+		const { data: draft } = await this.drafts.create({
+			refType: "post",
+			refId: id,
+			baseRevisionId: base.id,
+			data: mergeSnapshot(base, toDraftData(input))
+		});
+		return this.finish(draft, options);
+	}
+	async finish(draft, options) {
+		if (options.publish === false) return {
+			draft,
+			postId: draft.document.refId,
+			taskId: null
+		};
+		const task = await this.publishJobs.run({
+			branchId: draft.id,
+			revisionId: draft.headRevisionId,
+			expectedPublishedRevisionId: draft.document.publishedRevisionId,
+			confirmDiverged: draft.relationToPublished === "descendant" || draft.relationToPublished === "diverged",
+			aiResources: options.aiResources,
+			regenerateLockedTranslations: options.regenerateLockedTranslations
+		}, options);
+		return {
+			draft,
+			postId: task.result.articleId,
+			taskId: task.id
+		};
+	}
+};
+//#endregion
+//#region src/resources/tasks.ts
+const TERMINAL = /* @__PURE__ */ new Set([
+	"completed",
+	"partial_failed",
+	"failed",
+	"cancelled"
+]);
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	const timer = setTimeout(resolve, ms);
+	signal?.addEventListener("abort", () => {
+		clearTimeout(timer);
+		reject(signal.reason);
+	}, { once: true });
+});
+var TasksResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	get(id) {
+		return this.http.request("GET", `/tasks/${id}`);
+	}
+	cancel(id) {
+		return this.http.request("POST", `/tasks/${id}/cancel`);
+	}
+	async wait(id, options = {}) {
+		const intervalMs = options.intervalMs ?? 500;
+		const deadline = Date.now() + (options.timeoutMs ?? 12e4);
+		for (;;) {
+			const { data } = await this.get(id);
+			if (TERMINAL.has(data.status)) return data;
+			if (Date.now() > deadline) throw new BylineApiError(408, "TASK_TIMEOUT", `Task ${id} did not finish in time (last status: ${data.status})`, `/tasks/${id}`);
+			await sleep(intervalMs, options.signal);
+		}
+	}
+};
+var PublishJobsResource = class {
+	http;
+	tasks;
+	constructor(http, tasks) {
+		this.http = http;
+		this.tasks = tasks;
+	}
+	create(input) {
+		return this.http.request("POST", "/publish-jobs", { body: input });
+	}
+	async run(input, options) {
+		const { data: ref } = await this.create(input);
+		const task = await this.tasks.wait(ref.taskId, options);
+		if (task.status !== "completed" || !task.result?.articleId) throw new BylineApiError(500, "PUBLISH_FAILED", `Publish job ${ref.taskId} ended with ${task.status}${task.error ? `: ${task.error}` : ""}`, "/publish-jobs", { task });
+		return task;
+	}
+};
+//#endregion
+//#region src/resources/users.ts
+var UsersResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	allowLogin() {
+		return this.http.request("GET", "/users/allow-login");
+	}
+	checkLogged() {
+		return this.http.request("GET", "/users/check-logged");
+	}
+	me() {
+		return this.http.request("GET", "/users/me");
+	}
+	updateMe(input) {
+		return this.http.request("PATCH", "/users/me", { body: input });
+	}
+	list(query = {}) {
+		return this.http.request("GET", "/users", { query: { ...query } });
+	}
+	async listAll(query = {}) {
+		const users = [];
+		for (let page = 1;; page++) {
+			const { data, meta } = await this.list({
+				...query,
+				page,
+				size: 100
+			});
+			users.push(...data);
+			if (!meta || page >= meta.pagination.totalPages || !data.length) break;
+		}
+		return users;
+	}
+	get(id) {
+		return this.http.request("GET", `/users/${id}`);
+	}
+	update(id, input) {
+		return this.http.request("PATCH", `/users/${id}`, { body: input });
+	}
+	createProfileOnly(input) {
+		return this.http.request("POST", "/users/profile-only", { body: input });
+	}
+	deactivate(id) {
+		return this.http.request("POST", `/users/${id}/deactivate`);
+	}
+	reactivate(id) {
+		return this.http.request("POST", `/users/${id}/reactivate`);
+	}
+	invite(id, input = {}) {
+		return this.http.request("POST", `/users/${id}/invite`, { body: input });
+	}
+	initFirstUser(input) {
+		return this.http.request("POST", "/init/user", { body: input });
+	}
+};
+var InvitesResource = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	list() {
+		return this.http.request("GET", "/users/invites");
+	}
+	create(input) {
+		return this.http.request("POST", "/users/invites", { body: input });
+	}
+	revoke(id) {
+		return this.http.request("DELETE", `/users/invites/${id}`);
+	}
+	get(token) {
+		return this.http.request("GET", `/invites/${encodeURIComponent(token)}`);
+	}
+	accept(token, input) {
+		return this.http.request("POST", `/invites/${encodeURIComponent(token)}/accept`, { body: input });
+	}
+};
+//#endregion
+//#region src/client.ts
+var BylineClient = class {
+	http;
+	posts;
+	drafts;
+	publishJobs;
+	tasks;
+	categories;
+	translations;
+	users;
+	authors;
+	invites;
+	dynamicComponents;
+	files;
+	constructor(options) {
+		this.http = new HttpCore(options);
+		this.drafts = new DraftsResource(this.http);
+		this.tasks = new TasksResource(this.http);
+		this.publishJobs = new PublishJobsResource(this.http, this.tasks);
+		this.posts = new PostsResource(this.http, this.drafts, this.publishJobs);
+		this.categories = new CategoriesResource(this.http);
+		this.translations = new TranslationsResource(this.http);
+		this.users = new UsersResource(this.http);
+		this.authors = new AuthorsResource(this.http);
+		this.invites = new InvitesResource(this.http);
+		this.dynamicComponents = new DynamicComponentsResource(this.http);
+		this.files = new FilesResource(this.http);
+	}
+};
+const createClient = (options) => new BylineClient(options);
+//#endregion
+export { BylineApiError, BylineClient, HttpCore, camelcaseKeys, createClient, isBylineApiError, toDraftData };

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@mx-space/byline-api-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Typed fetch client for the Byline headless CMS API",
+  "keywords": [
+    "byline",
+    "headless-cms",
+    "api-client",
+    "lexical"
+  ],
+  "homepage": "https://github.com/mx-space/byline/tree/main/packages/api-client#readme",
+  "bugs": "https://github.com/mx-space/byline/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mx-space/byline.git",
+    "directory": "packages/api-client"
+  },
+  "license": "MIT",
+  "author": "Innei",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "tsdown": "0.22.8",
+    "typescript": "6.0.3",
+    "vitest": "5.0.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint src __tests__ --fix",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
 }