kizlo 0.1.0

package/dist/kizlo.js

@@ -0,0 +1,144 @@
+import { RPC_PROTOCOL_HEADER } from "./shared/constants.js";
+import { KizloError } from "./shared/error.js";
+import { createOrpcRouter } from "./shared/router.js";
+import { createResultClient } from "./shared/result.js";
+import { isTypescriptObject } from "./shared/utils.js";
+import { Context } from "./context.js";
+import { ROUTER_MAP } from "./router.js";
+import { createWebhookRouter } from "./webhook/index.js";
+import { tryCatch } from "@kizlo/shared";
+import { ORPCError, createRouterClient } from "@orpc/server";
+import { OpenAPIHandler } from "@orpc/openapi/fetch";
+import { RPCHandler } from "@orpc/server/fetch";
+
+//#region src/kizlo.ts
+var Kizlo = class {
+	context;
+	client;
+	router;
+	remoteHandler;
+	openapiHandler;
+	config;
+	constructor(config) {
+		this.config = config;
+		const extensions = this.registerExtensions();
+		this.context = new Context({
+			adapters: config.adapters,
+			siteSecret: config.siteSecret,
+			credentials: config.credentials
+		});
+		this.router = Object.assign(Object.assign({}, {
+			...extensions.router,
+			...ROUTER_MAP
+		}), { webhooks: createWebhookRouter({
+			path: this.config.webhookPath,
+			events: extensions.events
+		}) });
+		const orpcRouter = createOrpcRouter(this.router);
+		this.client = createResultClient(createRouterClient(orpcRouter, { context: this.context }));
+		this.remoteHandler = new RPCHandler(orpcRouter, {
+			filter: (options) => {
+				return this.checkInvocationScope(options.contract["~orpc"].meta, "remote");
+			},
+			interceptors: [this.errorInterceptor()]
+		});
+		this.openapiHandler = new OpenAPIHandler(orpcRouter, {
+			filter: (options) => {
+				return this.checkInvocationScope(options.contract["~orpc"].meta, "api");
+			},
+			interceptors: [this.errorInterceptor()],
+			customErrorResponseBodyEncoder(error) {
+				const { defined,...rest } = error.toJSON();
+				return rest;
+			}
+		});
+		this.handler = this.handler.bind(this);
+	}
+	async handler(request) {
+		const serverUrl = new URL(this.config.baseUrl);
+		const context = this.context.createRestContext(request);
+		const result = !(request.headers.get(RPC_PROTOCOL_HEADER) !== null) ? await this.openapiHandler.handle(request, {
+			context,
+			prefix: serverUrl.pathname
+		}) : await this.remoteHandler.handle(request, {
+			context,
+			prefix: serverUrl.pathname
+		});
+		if (!result.matched) return new Response("Not Found", { status: 404 });
+		for (const [key, value] of context.headers.entries()) if (key.toLowerCase() === "set-cookie") context.headers.getSetCookie().forEach((cookie) => {
+			result.response.headers.append("Set-Cookie", cookie);
+		});
+		else result.response.headers.set(key, value);
+		return result.response;
+	}
+	errorInterceptor() {
+		return async ({ next }) => {
+			const [err, data] = await tryCatch(next());
+			if (err) {
+				if (err instanceof KizloError) throw new ORPCError(err.code, {
+					status: err.status,
+					message: err.message,
+					data: err.data
+				});
+				console.log(err);
+				throw err;
+			}
+			return data;
+		};
+	}
+	checkInvocationScope(value, scope) {
+		return isTypescriptObject(value) && "scope" in value && value.scope === scope;
+	}
+	registerExtensions() {
+		const router = {};
+		const events = [];
+		for (const extension of this.config.extensions ?? []) {
+			const data = extension.init({ context: { something: "" } });
+			if (data.router) router[extension.id] = data.router;
+			for (const handler of data.events ?? []) events.push(handler);
+		}
+		return {
+			events,
+			router
+		};
+	}
+};
+function requireEnv(name) {
+	const value = process.env[name]?.trim();
+	if (!value) throw new KizloError("MISSING_ENV_VARIABLE", { message: `Please define ${name} in your .env file.` });
+	return value;
+}
+/**
+* Resolves a full `KizloConfig` from options and the environment. Shared by the
+* base `createKizlo` and each framework factory — the single place env values
+* and credentials are read. `baseUrlEnvKey` is the only framework-varying part.
+*/
+function resolveKizloConfig(options, defaults) {
+	const credentials = options?.wordpress?.credentials;
+	return {
+		baseUrl: options?.baseUrl ?? requireEnv(defaults.baseUrlEnvKey),
+		siteSecret: options?.siteSecret ?? requireEnv("SITE_SECRET"),
+		environment: options?.environment ?? process.env.NODE_ENV ?? "development",
+		extensions: options?.extensions,
+		adapters: {
+			...defaults.adapters,
+			...options?.adapters
+		},
+		credentials: {
+			url: credentials?.url ?? requireEnv("WORDPRESS_URL"),
+			username: credentials?.username ?? requireEnv("WORDPRESS_USERNAME"),
+			password: credentials?.password ?? requireEnv("WORDPRESS_APPLICATION_PASSWORD")
+		}
+	};
+}
+/**
+* Creates a Kizlo server from the environment (`SERVER_BASE_URL`, `SITE_SECRET`,
+* `WORDPRESS_*`), with options taking precedence. Framework packages wrap this
+* with their own URL convention and adapters.
+*/
+function createKizlo(options) {
+	return new Kizlo(resolveKizloConfig(options, { baseUrlEnvKey: "SERVER_BASE_URL" }));
+}
+
+//#endregion
+export { Kizlo, createKizlo, resolveKizloConfig };

package/dist/menu/errors.js

@@ -0,0 +1,16 @@
+import { defineErrorMap } from "../shared/error.js";
+
+//#region src/menu/errors.ts
+const LIST_MENU_ITEM_ERROR_MAP = defineErrorMap({
+	MENU_ITEM_INVALID_PAGE: {
+		status: 400,
+		message: "The requested page does not exist."
+	},
+	MENU_ITEM_FORBIDDEN: {
+		status: 403,
+		message: "You are not allowed to view menu items."
+	}
+});
+
+//#endregion
+export { LIST_MENU_ITEM_ERROR_MAP };

package/dist/menu/fixture.d.ts

@@ -0,0 +1,8 @@
+import { Fixture } from "../cli/wp/types.js";
+import "../test.js";
+
+//#region src/menu/fixture.d.ts
+/** Core menu fixture: seeds a `primary` nav menu + items so the menu suite has content to read. */
+declare function menuFixture(): Fixture;
+//#endregion
+export { menuFixture };

package/dist/menu/fixture.js

@@ -0,0 +1,62 @@
+import { defineFixture } from "../cli/wp/types.js";
+
+//#region src/menu/fixture.ts
+const MENU = {
+	name: "Primary",
+	slug: "primary",
+	items: [
+		{
+			label: "Home",
+			url: "/"
+		},
+		{
+			label: "About",
+			url: "/about"
+		},
+		{
+			label: "Contact",
+			url: "/contact"
+		}
+	]
+};
+async function upsertMenu(ctx) {
+	const existing = await ctx.service.menus.list({ per_page: 100 });
+	if (existing.error) throw existing.error;
+	const found = existing.data.items.find((menu) => menu.slug === MENU.slug);
+	if (found) return found.id;
+	const created = await ctx.service.menus.create({ name: MENU.name });
+	if (created.error) throw created.error;
+	return created.data.id;
+}
+async function seedItems(ctx, menuId) {
+	const existing = await ctx.service.menus.items.list({
+		menus: menuId,
+		per_page: 1
+	});
+	if (existing.error) throw existing.error;
+	if (existing.data.items.length > 0) return;
+	for (const item of MENU.items) {
+		const created = await ctx.service.menus.items.create({
+			menus: menuId,
+			title: item.label,
+			url: item.url,
+			type: "custom",
+			status: "publish"
+		});
+		if (created.error) throw created.error;
+	}
+}
+/** Core menu fixture: seeds a `primary` nav menu + items so the menu suite has content to read. */
+function menuFixture() {
+	return defineFixture({
+		name: "menu",
+		async seed(ctx) {
+			const menuId = await upsertMenu(ctx);
+			await seedItems(ctx, menuId);
+			return { menuId };
+		}
+	});
+}
+
+//#endregion
+export { menuFixture };

package/dist/menu/index.js

@@ -0,0 +1,70 @@
+import { createProcedure } from "../shared/procedure.js";
+import { deserializeListMetadata } from "../shared/serialize.js";
+import { LIST_MENU_ITEM_ERROR_MAP } from "./errors.js";
+import { ListMenuInput, MenuGroupItemList, MenuItemList } from "./schema.js";
+import { buildMenuGroupItem, deserializeListMenuInput, extractSlugFromUrl } from "./utils.js";
+import { stringifiedMetaRecord } from "@kizlo/shared";
+
+//#region src/menu/index.ts
+const MENU_ROUTER_MAP = { items: {
+	list: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/site/menus",
+		output: MenuItemList,
+		query: ListMenuInput.optional(),
+		errors: LIST_MENU_ITEM_ERROR_MAP
+	}, async ({ context, errors, input }) => {
+		const response = await context.service.wordpress.menus.items.list(deserializeListMenuInput(input.query));
+		if (response.error) switch (response.error.code) {
+			case "rest_post_invalid_page_number": throw errors.MENU_ITEM_INVALID_PAGE();
+			case "rest_cannot_view": throw errors.MENU_ITEM_FORBIDDEN();
+			default:
+				context.logger.error("List menu items unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return {
+			items: response.data.items.map((item) => {
+				const href = item.object !== "custom" ? extractSlugFromUrl(item.url) : item.url;
+				return {
+					id: item.id,
+					href,
+					name: item.title.rendered,
+					description: item.description,
+					type: item.object,
+					meta: stringifiedMetaRecord(item.meta ?? {})
+				};
+			}),
+			meta: deserializeListMetadata(response.data.meta)
+		};
+	}),
+	groupList: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/menus/group",
+		query: ListMenuInput.optional(),
+		errors: LIST_MENU_ITEM_ERROR_MAP,
+		output: MenuGroupItemList
+	}, async ({ context, errors, input }) => {
+		const response = await context.service.wordpress.menus.items.list(deserializeListMenuInput(input.query));
+		if (response.error) switch (response.error.code) {
+			case "rest_post_invalid_page_number": throw errors.MENU_ITEM_INVALID_PAGE();
+			case "rest_cannot_view": throw errors.MENU_ITEM_FORBIDDEN();
+			default:
+				context.logger.error("Group list menu items unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const itemMap = /* @__PURE__ */ new Map();
+		response.data.items.forEach((item) => {
+			itemMap.set(item.id, item);
+		});
+		const rootItems = response.data.items.filter((item) => item.parent === 0 || !itemMap.has(item.parent)).sort((a, b) => a.menu_order - b.menu_order);
+		return {
+			meta: deserializeListMetadata(response.data.meta),
+			items: rootItems.map((rootItem) => buildMenuGroupItem(rootItem, response.data.items))
+		};
+	})
+} };
+
+//#endregion
+export { MENU_ROUTER_MAP };

package/dist/menu/schema.js

@@ -0,0 +1,70 @@
+import { ListMetadata, ListOrder } from "../shared/schema.js";
+import { Metadata, NumberLike, arrayable } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/menu/schema.ts
+const MENU_TYPES = [
+	"page",
+	"post",
+	"category",
+	"product",
+	"product_cat",
+	"product_tag",
+	"custom"
+];
+const MenuType = z.enum(MENU_TYPES);
+const MenuItem = z.object({
+	id: z.number(),
+	href: z.string(),
+	name: z.string(),
+	type: MenuType,
+	description: z.string(),
+	meta: Metadata
+});
+const MenuGroupItem = z.lazy(() => MenuItem.extend({
+	items: z.array(MenuGroupItem),
+	hasItems: z.boolean(),
+	meta: Metadata
+}));
+const MenuItemList = z.object({
+	items: z.array(MenuItem),
+	meta: ListMetadata
+});
+const MenuGroupItemList = z.object({
+	items: z.array(MenuGroupItem),
+	meta: ListMetadata
+});
+const MENU_ITEM_ORDER_BYES = [
+	"author",
+	"date",
+	"id",
+	"include",
+	"parent",
+	"relevance",
+	"slug",
+	"include_slugs",
+	"title",
+	"menu_order"
+];
+const MenuItemOrderBy = z.enum(MENU_ITEM_ORDER_BYES);
+const ListMenuInput = z.object({
+	page: NumberLike.optional(),
+	perPage: NumberLike.optional(),
+	search: z.string().optional(),
+	after: z.string().optional(),
+	before: z.string().optional(),
+	exclude: arrayable(NumberLike).optional(),
+	include: arrayable(NumberLike).optional(),
+	offset: NumberLike.optional(),
+	order: ListOrder.optional(),
+	orderby: MenuItemOrderBy.optional(),
+	searchColumns: z.array(z.string()).optional(),
+	slug: arrayable(z.string()).optional(),
+	taxRelation: z.enum(["AND", "OR"]).optional(),
+	menus: arrayable(NumberLike).optional(),
+	menusExclude: arrayable(NumberLike).optional(),
+	menuOrder: NumberLike.optional()
+});
+
+//#endregion
+export { ListMenuInput, MenuGroupItemList, MenuItemList };

package/dist/menu/utils.js

@@ -0,0 +1,57 @@
+import { stringifiedMetaRecord } from "@kizlo/shared";
+
+//#region src/menu/utils.ts
+function deserializeListMenuInput(input) {
+	return {
+		context: "edit",
+		after: input?.after,
+		before: input?.before,
+		exclude: input?.exclude,
+		include: input?.include,
+		menu_order: input?.menuOrder,
+		menus: input?.menus,
+		menus_exclude: input?.menusExclude,
+		offset: input?.offset,
+		order: input?.order,
+		orderby: input?.orderby,
+		page: input?.page,
+		per_page: input?.perPage,
+		search: input?.search,
+		slug: input?.slug,
+		tax_relation: input?.taxRelation,
+		search_columns: input?.searchColumns,
+		status: "publish"
+	};
+}
+function extractSlugFromUrl(url) {
+	if (!url || url.trim() === "") return "/";
+	const trimmed = url.trim();
+	let pathname;
+	if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) try {
+		pathname = new URL(trimmed).pathname;
+	} catch {
+		pathname = trimmed;
+	}
+	else pathname = trimmed;
+	const cleanPath = pathname.replace(/^\/+|\/+$/g, "");
+	if (!cleanPath) return "/";
+	const segments = cleanPath.split("/");
+	return segments[segments.length - 1] ?? "/";
+}
+function buildMenuGroupItem(wpItem, items) {
+	const children = items.filter((item) => item.parent === wpItem.id).sort((a, b) => a.menu_order - b.menu_order).map((child) => buildMenuGroupItem(child, items));
+	const href = wpItem.object !== "custom" ? extractSlugFromUrl(wpItem.url) : wpItem.url;
+	return {
+		id: wpItem.id,
+		href,
+		name: wpItem.title.rendered,
+		description: wpItem.description,
+		type: wpItem.object,
+		items: children,
+		hasItems: children.length > 0,
+		meta: stringifiedMetaRecord(wpItem.meta ?? {})
+	};
+}
+
+//#endregion
+export { buildMenuGroupItem, deserializeListMenuInput, extractSlugFromUrl };

package/dist/nextjs/server.d.ts

@@ -0,0 +1,2 @@
+import { KizloServerOptions, createKizlo } from "../integrations/nextjs/kizlo.server.js";
+export { KizloServerOptions, createKizlo };

package/dist/nextjs/server.js

@@ -0,0 +1,3 @@
+import { createKizlo } from "../integrations/nextjs/kizlo.server.js";
+
+export { createKizlo };

package/dist/nextjs.d.ts

@@ -0,0 +1,2 @@
+import { KizloClientOptions, createKizloClient } from "./integrations/nextjs/kizlo.client.js";
+export { KizloClientOptions, createKizloClient };

package/dist/nextjs.js

@@ -0,0 +1,3 @@
+import { createKizloClient } from "./integrations/nextjs/kizlo.client.js";
+
+export { createKizloClient };

package/dist/package.js

@@ -0,0 +1,5 @@
+//#region package.json
+var version = "0.1.0";
+
+//#endregion
+export { version };

package/dist/post/error.js

@@ -0,0 +1,30 @@
+import { defineErrorMap } from "../shared/error.js";
+
+//#region src/post/error.ts
+const GET_POST_ERROR_MAP = defineErrorMap({
+	POST_NOT_FOUND: {
+		status: 404,
+		message: "Post not found"
+	},
+	POST_PASSWORD_INVALID: {
+		status: 400,
+		message: "Invalid post password."
+	}
+});
+const LIST_POST_ERROR_MAP = defineErrorMap({
+	POST_INVALID_PAGE: {
+		status: 400,
+		message: "The requested page does not exist."
+	},
+	POST_SEARCH_REQUIRED: {
+		status: 400,
+		message: "A search term is required."
+	},
+	POST_ORDERBY_INCLUDE_MISSING: {
+		status: 400,
+		message: "Ordering by 'include' requires the include parameter."
+	}
+});
+
+//#endregion
+export { GET_POST_ERROR_MAP, LIST_POST_ERROR_MAP };

package/dist/post/fixture.d.ts

@@ -0,0 +1,8 @@
+import { Fixture } from "../cli/wp/types.js";
+import "../test.js";
+
+//#region src/post/fixture.d.ts
+/** Core post fixture: seeds sample posts + comments so the post/comment suites have content to read. */
+declare function postFixture(): Fixture;
+//#endregion
+export { postFixture };

package/dist/post/fixture.js

@@ -0,0 +1,71 @@
+import { defineFixture } from "../cli/wp/types.js";
+
+//#region src/post/fixture.ts
+const POSTS = [{
+	slug: "hello-world-test",
+	title: "Hello World Test",
+	content: "First seeded post.",
+	comments: [{
+		author: "customer",
+		email: "customer@example.com",
+		content: "Seed comment"
+	}]
+}, {
+	slug: "second-test-post",
+	title: "Second Test Post",
+	content: "Second seeded post."
+}];
+async function upsertPost(ctx, post) {
+	const existing = await ctx.service.posts.list({
+		slug: post.slug,
+		per_page: 1
+	});
+	if (existing.error) throw existing.error;
+	if (existing.data.items[0]) return existing.data.items[0].id;
+	const created = await ctx.service.posts.create({
+		slug: post.slug,
+		title: post.title,
+		content: post.content,
+		status: "publish",
+		author: ctx.adminId
+	});
+	if (created.error) throw created.error;
+	return created.data.id;
+}
+async function seedComments(ctx, postId, comments) {
+	if (!comments?.length) return;
+	const existing = await ctx.service.comments.list({
+		post: postId,
+		per_page: 1
+	});
+	if (existing.error) throw existing.error;
+	if (existing.data.items.length > 0) return;
+	for (const comment of comments) {
+		const created = await ctx.service.comments.create({
+			post: postId,
+			content: comment.content,
+			author_name: comment.author,
+			author_email: comment.email,
+			status: "approve"
+		});
+		if (created.error) throw created.error;
+	}
+}
+/** Core post fixture: seeds sample posts + comments so the post/comment suites have content to read. */
+function postFixture() {
+	return defineFixture({
+		name: "post",
+		async seed(ctx) {
+			let postId = 0;
+			for (const post of POSTS) {
+				const id = await upsertPost(ctx, post);
+				if (!postId) postId = id;
+				await seedComments(ctx, id, post.comments);
+			}
+			return { postId };
+		}
+	});
+}
+
+//#endregion
+export { postFixture };

package/dist/post/index.js

@@ -0,0 +1,123 @@
+import { createProcedure } from "../shared/procedure.js";
+import { compare } from "../shared/crypto.js";
+import { deserializeListMetadata } from "../shared/serialize.js";
+import { getPostTypeService } from "../post-type/service.js";
+import { parseIdentifier } from "../shared/identifier.js";
+import { GET_POST_ERROR_MAP, LIST_POST_ERROR_MAP } from "./error.js";
+import { ListPostInput, Post, PostList, RetrievePostInput } from "./schema.js";
+import { deserializePost } from "./utils.js";
+
+//#region src/post/index.ts
+const POST_ROUTER_MAP = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/posts/{identifier}",
+		params: RetrievePostInput.pick({ identifier: true }),
+		query: RetrievePostInput.pick({
+			password: true,
+			previewToken: true
+		}).optional(),
+		output: Post,
+		errors: GET_POST_ERROR_MAP
+	}, async ({ input, context, errors }) => {
+		const postType = getPostTypeService("post", context.service.wordpress);
+		if (input.query?.previewToken) {
+			const result = await context.verifyPreviewToken(input.query.previewToken);
+			if (!result) throw errors.POST_NOT_FOUND();
+			const response$1 = await postType.get({
+				type: "id",
+				value: result.id
+			});
+			if (response$1.error) switch (response$1.error.code) {
+				case "rest_post_invalid_id": throw errors.POST_NOT_FOUND();
+				case "rest_post_incorrect_password": throw errors.POST_PASSWORD_INVALID();
+				default:
+					context.logger.error("Get post preview unhandled error", response$1.error, {
+						id: result.id,
+						code: response$1.error.code
+					});
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializePost({
+				...response$1.data,
+				password: ""
+			});
+		}
+		const identifier = parseIdentifier(input.params.identifier);
+		if (!identifier) throw errors.POST_NOT_FOUND();
+		const response = await postType.get(identifier);
+		if (response.error) switch (response.error.code) {
+			case "rest_post_invalid_id": throw errors.POST_NOT_FOUND();
+			case "rest_post_incorrect_password": throw errors.POST_PASSWORD_INVALID();
+			default:
+				context.logger.error("Get post unhandled error", response.error, {
+					identifier,
+					code: response.error.code
+				});
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const data = response.data;
+		if (input.query?.password && data.password) {
+			if (!compare(input.query.password, data.password)) throw errors.POST_PASSWORD_INVALID();
+			return deserializePost({
+				...data,
+				password: ""
+			});
+		}
+		return deserializePost(data);
+	}),
+	list: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/posts",
+		query: ListPostInput.optional(),
+		output: PostList,
+		errors: LIST_POST_ERROR_MAP
+	}, async ({ input, context, errors }) => {
+		const response = await getPostTypeService("post", context.service.wordpress).list({
+			context: "edit",
+			status: "publish",
+			after: input.query?.after,
+			author: input.query?.author,
+			author_exclude: input.query?.authorExclude,
+			before: input.query?.before,
+			categories: input.query?.categories,
+			categories_exclude: input.query?.categoriesExclude,
+			exclude: input.query?.exclude,
+			include: input.query?.include,
+			offset: input.query?.offset,
+			order: input.query?.order,
+			orderby: input.query?.orderby,
+			page: input.query?.page,
+			per_page: input.query?.perPage,
+			search: input.query?.search,
+			search_columns: input.query?.searchColumns,
+			slug: input.query?.slug,
+			sticky: input.query?.sticky,
+			tags: input.query?.tags,
+			tags_exclude: input.query?.tagsExclude,
+			tax_relation: input.query?.taxRelation
+		});
+		if (response.error) switch (response.error.code) {
+			case "rest_post_invalid_page_number": throw errors.POST_INVALID_PAGE();
+			case "rest_no_search_term_defined": throw errors.POST_SEARCH_REQUIRED();
+			case "rest_orderby_include_missing_include": throw errors.POST_ORDERBY_INCLUDE_MISSING();
+			default:
+				context.logger.error("List posts unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const list = context.service.wordpress.resolveList({
+			data: response.data,
+			headers: response.headers,
+			searchParams: input.query
+		});
+		return {
+			meta: deserializeListMetadata(list.meta),
+			items: list.items.map(deserializePost)
+		};
+	})
+};
+
+//#endregion
+export { POST_ROUTER_MAP };