kizlo 0.6.1 → 0.8.0

package/dist/page/index.js

@@ -0,0 +1,128 @@
+import { compare } from "../shared/crypto.js";
+import { createProcedure } from "../shared/procedure.js";
+import { parseIdentifier } from "../shared/identifier.js";
+import { deserializeListMetadata } from "../shared/serialize.js";
+import { getPostTypeService } from "../post-type/service.js";
+import { GET_PAGE_ERROR_MAP, LIST_PAGE_ERROR_MAP } from "./error.js";
+import { ListPageInput, Page, PageList, RetrievePageInput } from "./schema.js";
+import { deserializePage } from "./utils.js";
+
+//#region src/page/index.ts
+const PAGE_ROUTER_MAP = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/pages/{identifier}",
+		params: RetrievePageInput.pick({ identifier: true }),
+		query: RetrievePageInput.pick({
+			password: true,
+			previewToken: true
+		}).optional(),
+		output: Page,
+		errors: GET_PAGE_ERROR_MAP
+	}, async ({ input, context, errors }) => {
+		const postType = getPostTypeService("page", context.wordpress);
+		if (input.query?.previewToken) {
+			const result = await context.verifyPreviewToken(input.query.previewToken);
+			if (!result) throw errors.PAGE_NOT_FOUND();
+			const response$1 = await postType.get({
+				type: "id",
+				value: result.id
+			});
+			if (response$1.error) switch (response$1.error.code) {
+				case "invalid_post_type":
+				case "post_type_not_found":
+				case "rest_post_invalid_id": throw errors.PAGE_NOT_FOUND();
+				case "rest_post_incorrect_password": throw errors.PAGE_PASSWORD_INVALID();
+				default:
+					context.logger.error("Get page preview unhandled error", response$1.error, {
+						id: result.id,
+						code: response$1.error.code
+					});
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializePage({
+				...response$1.data,
+				password: ""
+			}, { preview: true });
+		}
+		const identifier = parseIdentifier(input.params.identifier);
+		if (!identifier) throw errors.PAGE_NOT_FOUND();
+		const response = await postType.get(identifier);
+		if (response.error) switch (response.error.code) {
+			case "invalid_post_type":
+			case "post_type_not_found":
+			case "rest_post_invalid_id": throw errors.PAGE_NOT_FOUND();
+			case "rest_post_incorrect_password": throw errors.PAGE_PASSWORD_INVALID();
+			default:
+				context.logger.error("Get page unhandled error", response.error, {
+					identifier,
+					code: response.error.code
+				});
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const data = response.data;
+		if (data.status !== "publish") throw errors.PAGE_NOT_FOUND();
+		if (input.query?.password && data.password) {
+			if (!await compare(input.query.password, data.password)) throw errors.PAGE_PASSWORD_INVALID();
+			return deserializePage({
+				...data,
+				password: ""
+			});
+		}
+		return deserializePage(data);
+	}),
+	list: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/pages",
+		query: ListPageInput.optional(),
+		output: PageList,
+		errors: LIST_PAGE_ERROR_MAP
+	}, async ({ input, context, errors }) => {
+		const q = input.query;
+		const postType = getPostTypeService("page", context.wordpress);
+		const orderby = q?.orderby === "relevance" && !q?.search || q?.orderby === "include" && q?.include === void 0 ? void 0 : q?.orderby;
+		const response = await postType.list({
+			context: "edit",
+			status: "publish",
+			after: input.query?.after,
+			author: input.query?.author,
+			author_exclude: input.query?.authorExclude,
+			before: input.query?.before,
+			modified_after: input.query?.modifiedAfter,
+			modified_before: input.query?.modifiedBefore,
+			exclude: input.query?.exclude,
+			include: input.query?.include,
+			menu_order: input.query?.menuOrder,
+			offset: input.query?.offset,
+			order: input.query?.order,
+			orderby,
+			page: input.query?.page,
+			parent: input.query?.parent,
+			parent_exclude: input.query?.parentExclude,
+			per_page: input.query?.perPage,
+			search: input.query?.search,
+			search_columns: input.query?.searchColumns,
+			slug: input.query?.slug
+		});
+		if (response.error) switch (response.error.code) {
+			case "rest_post_invalid_page_number": throw errors.PAGE_INVALID_PAGE();
+			default:
+				context.logger.error("List pages unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const list = context.wordpress.resolveList({
+			data: response.data,
+			headers: response.headers,
+			searchParams: input.query
+		});
+		return {
+			meta: deserializeListMetadata(list.meta),
+			items: list.items.map((item) => deserializePage(item))
+		};
+	})
+};
+
+//#endregion
+export { PAGE_ROUTER_MAP };

package/dist/page/schema.js

@@ -0,0 +1,75 @@
+import { IdentifierInput, ListMetadata, ListOrder, Media } from "../shared/schema.js";
+import { WP_PAGE_ORDER_BYES, WP_PAGE_STATUSES } from "../wordpress/page/types.js";
+import { Seo } from "../seo/schema.js";
+import { Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/page/schema.ts
+const PageStatus = z.enum(WP_PAGE_STATUSES).exclude(["trash"]);
+const PageAuthorRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string(),
+	avatar: Media.nullable()
+});
+const Page = z.object({
+	id: z.number(),
+	slug: z.string(),
+	url: z.string().nullable(),
+	parent: z.number().nullable(),
+	menuOrder: z.number(),
+	template: z.string(),
+	title: z.string().nullable(),
+	content: z.string().nullable(),
+	excerpt: z.string().nullable(),
+	commentsEnabled: z.boolean(),
+	protected: z.boolean(),
+	preview: z.boolean(),
+	status: PageStatus,
+	author: PageAuthorRef.nullable(),
+	featuredMedia: Media.nullable(),
+	seo: Seo.nullable(),
+	createdAt: z.number(),
+	updatedAt: z.number(),
+	meta: Metadata
+});
+const RetrievePageInput = z.object({
+	identifier: IdentifierInput,
+	password: z.string().optional(),
+	previewToken: z.string().optional()
+});
+const PageList = z.object({
+	items: z.array(Page),
+	meta: ListMetadata
+});
+const PageOrderBy = z.enum(WP_PAGE_ORDER_BYES);
+const PAGE_SEARCH_COLUMNS = [
+	"post_title",
+	"post_content",
+	"post_excerpt"
+];
+const PageSearchColumn = z.enum(PAGE_SEARCH_COLUMNS);
+const ListPageInput = z.object({
+	page: NumberLike.pipe(z.number().int().min(1)).catch(1).optional(),
+	perPage: lenient(NumberLike.pipe(z.number().int().min(1).max(100))),
+	search: lenient(z.string()),
+	after: lenient(z.string()),
+	before: lenient(z.string()),
+	modifiedAfter: lenient(z.string()),
+	modifiedBefore: lenient(z.string()),
+	author: lenient(arrayable(NumberLike)),
+	authorExclude: lenient(arrayable(NumberLike)),
+	exclude: lenient(arrayable(NumberLike)),
+	include: lenient(arrayable(NumberLike)),
+	offset: lenient(NumberLike.pipe(z.number().int().min(0))),
+	order: lenient(ListOrder),
+	orderby: lenient(PageOrderBy),
+	searchColumns: lenient(z.array(PageSearchColumn)),
+	slug: lenient(arrayable(z.string())),
+	parent: lenient(arrayable(NumberLike)),
+	parentExclude: lenient(arrayable(NumberLike)),
+	menuOrder: lenient(NumberLike)
+});
+
+//#endregion
+export { ListPageInput, Page, PageList, RetrievePageInput };

package/dist/page/utils.js

@@ -0,0 +1,43 @@
+import { deserializeSeo } from "../seo/utils.js";
+import { resolveWpTimestamp, stringifiedMetaRecord } from "@kizlo/shared";
+
+//#region src/page/utils.ts
+function deserializePage(data, options) {
+	const locked = data.password.length > 0;
+	const kizlo = data.kizlo;
+	const title = data.title.rendered;
+	return {
+		id: data.id,
+		url: kizlo.url ?? null,
+		parent: data.parent || null,
+		menuOrder: data.menu_order ?? 0,
+		template: data.template ?? "",
+		title: title.length > 0 ? title : null,
+		content: locked ? null : data.content?.rendered ?? null,
+		excerpt: locked ? null : data.excerpt?.rendered ?? null,
+		protected: locked,
+		preview: options?.preview ?? false,
+		status: data.status === "trash" ? "draft" : data.status,
+		featuredMedia: kizlo.featured_media ?? null,
+		commentsEnabled: data.comment_status === "open",
+		slug: data.slug,
+		author: kizlo.author ? {
+			id: kizlo.author.id,
+			name: kizlo.author.name,
+			slug: kizlo.author.slug,
+			avatar: kizlo.author.avatar_url ? {
+				id: 0,
+				alt: kizlo.author.name,
+				name: kizlo.author.name,
+				src: kizlo.author.avatar_url
+			} : null
+		} : null,
+		seo: kizlo.seo ? deserializeSeo(kizlo.seo) : null,
+		createdAt: resolveWpTimestamp(data.date_gmt) ?? resolveWpTimestamp(data.modified_gmt) ?? 0,
+		updatedAt: resolveWpTimestamp(data.modified_gmt) ?? 0,
+		meta: stringifiedMetaRecord(data.meta ?? {})
+	};
+}
+
+//#endregion
+export { deserializePage };

package/dist/post/error.js

@@ -11,20 +11,10 @@ const GET_POST_ERROR_MAP = defineErrorMap({
 		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."
-	}
-});
+const LIST_POST_ERROR_MAP = defineErrorMap({ POST_INVALID_PAGE: {
+	status: 400,
+	message: "The requested page does not exist."
+} });
 
 //#endregion
 export { GET_POST_ERROR_MAP, LIST_POST_ERROR_MAP };

package/dist/post/index.js

@@ -1,8 +1,8 @@
 import { compare } from "../shared/crypto.js";
 import { createProcedure } from "../shared/procedure.js";
+import { parseIdentifier } from "../shared/identifier.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";
@@ -21,7 +21,7 @@ const POST_ROUTER_MAP = {
 		output: Post,
 		errors: GET_POST_ERROR_MAP
 	}, async ({ input, context, errors }) => {
-		const postType = getPostTypeService("post", context.service.wordpress);
+		const postType = getPostTypeService("post", context.wordpress);
 		if (input.query?.previewToken) {
 			const result = await context.verifyPreviewToken(input.query.previewToken);
 			if (!result) throw errors.POST_NOT_FOUND();
@@ -30,6 +30,8 @@ const POST_ROUTER_MAP = {
 				value: result.id
 			});
 			if (response$1.error) switch (response$1.error.code) {
+				case "invalid_post_type":
+				case "post_type_not_found":
 				case "rest_post_invalid_id": throw errors.POST_NOT_FOUND();
 				case "rest_post_incorrect_password": throw errors.POST_PASSWORD_INVALID();
 				default:
@@ -42,12 +44,14 @@ const POST_ROUTER_MAP = {
 			return deserializePost({
 				...response$1.data,
 				password: ""
-			});
+			}, { preview: true });
 		}
 		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 "invalid_post_type":
+			case "post_type_not_found":
 			case "rest_post_invalid_id": throw errors.POST_NOT_FOUND();
 			case "rest_post_incorrect_password": throw errors.POST_PASSWORD_INVALID();
 			default:
@@ -58,6 +62,7 @@ const POST_ROUTER_MAP = {
 				throw errors.INTERNAL_SERVER_ERROR();
 		}
 		const data = response.data;
+		if (data.status !== "publish") throw errors.POST_NOT_FOUND();
 		if (input.query?.password && data.password) {
 			if (!await compare(input.query.password, data.password)) throw errors.POST_PASSWORD_INVALID();
 			return deserializePost({
@@ -75,20 +80,25 @@ const POST_ROUTER_MAP = {
 		output: PostList,
 		errors: LIST_POST_ERROR_MAP
 	}, async ({ input, context, errors }) => {
-		const response = await getPostTypeService("post", context.service.wordpress).list({
+		const q = input.query;
+		const postType = getPostTypeService("post", context.wordpress);
+		const orderby = q?.orderby === "relevance" && !q?.search || q?.orderby === "include" && q?.include === void 0 ? void 0 : q?.orderby;
+		const response = await postType.list({
 			context: "edit",
 			status: "publish",
 			after: input.query?.after,
 			author: input.query?.author,
 			author_exclude: input.query?.authorExclude,
 			before: input.query?.before,
+			modified_after: input.query?.modifiedAfter,
+			modified_before: input.query?.modifiedBefore,
 			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,
+			orderby,
 			page: input.query?.page,
 			per_page: input.query?.perPage,
 			search: input.query?.search,
@@ -101,20 +111,18 @@ const POST_ROUTER_MAP = {
 		});
 		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({
+		const list = context.wordpress.resolveList({
 			data: response.data,
 			headers: response.headers,
 			searchParams: input.query
 		});
 		return {
 			meta: deserializeListMetadata(list.meta),
-			items: list.items.map(deserializePost)
+			items: list.items.map((item) => deserializePost(item))
 		};
 	})
 };

package/dist/post/schema.js

@@ -1,46 +1,16 @@
 import { IdentifierInput, ListMetadata, ListOrder, Media } from "../shared/schema.js";
+import { WP_POST_FORMATS, WP_POST_ORDER_BYES, WP_POST_STATUSES, WP_POST_TAX_RELATIONS } from "../wordpress/post/types.js";
 import { Seo } from "../seo/schema.js";
-import { BooleanLike, Metadata, NumberLike, arrayable } from "@kizlo/shared";
+import { BooleanLike, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
 import z from "zod/v4";
 
 //#region src/post/schema.ts
-const POST_TYPE_FORMATS = [
-	"standard",
-	"aside",
-	"chat",
-	"gallery",
-	"link",
-	"image",
-	"quote",
-	"status",
-	"video",
-	"audio"
-];
-const PostTypeFormat = z.enum(POST_TYPE_FORMATS);
-const POST_STATUSES = [
-	"publish",
-	"future",
-	"draft",
-	"pending",
-	"private"
-];
-const PostStatus = z.enum(POST_STATUSES);
-const POST_COMMENT_STATUSES = [
-	"approved",
-	"hold",
-	"spam",
-	"trash"
-];
-const PostCommentStatus = z.enum(POST_COMMENT_STATUSES);
-const POST_COMMENT_TYPES = [
-	"comment",
-	"pingback",
-	"trackback"
-];
-const PostCommentType = z.enum(POST_COMMENT_TYPES);
+const PostTypeFormat = z.enum(WP_POST_FORMATS);
+const PostStatus = z.enum(WP_POST_STATUSES).exclude(["trash"]);
 const PostAuthorRef = z.object({
 	id: z.number(),
 	name: z.string(),
+	slug: z.string(),
 	avatar: Media.nullable()
 });
 const PostCategoryRef = z.object({
@@ -56,11 +26,15 @@ const PostTagRef = z.object({
 const Post = z.object({
 	id: z.number(),
 	slug: z.string(),
+	url: z.string().nullable(),
+	parent: z.number().nullable(),
 	title: z.string().nullable(),
 	content: z.string().nullable(),
 	excerpt: z.string().nullable(),
 	commentsEnabled: z.boolean(),
 	protected: z.boolean(),
+	preview: z.boolean(),
+	status: PostStatus,
 	format: PostTypeFormat,
 	sticky: z.boolean(),
 	author: PostAuthorRef.nullable(),
@@ -81,39 +55,36 @@ const PostList = z.object({
 	items: z.array(Post),
 	meta: ListMetadata
 });
-const POST_ORDER_BYES = [
-	"author",
-	"date",
-	"id",
-	"include",
-	"parent",
-	"relevance",
-	"slug",
-	"include_slugs",
-	"title"
+const PostOrderBy = z.enum(WP_POST_ORDER_BYES);
+const POST_SEARCH_COLUMNS = [
+	"post_title",
+	"post_content",
+	"post_excerpt"
 ];
-const PostOrderBy = z.enum(POST_ORDER_BYES);
+const PostSearchColumn = z.enum(POST_SEARCH_COLUMNS);
 const ListPostInput = z.object({
-	page: NumberLike.optional(),
-	perPage: NumberLike.optional(),
-	search: z.string().optional(),
-	after: z.string().optional(),
-	before: z.string().optional(),
-	author: arrayable(NumberLike).optional(),
-	authorExclude: arrayable(NumberLike).optional(),
-	exclude: arrayable(NumberLike).optional(),
-	include: arrayable(NumberLike).optional(),
-	offset: NumberLike.optional(),
-	order: ListOrder.optional(),
-	orderby: PostOrderBy.optional(),
-	searchColumns: z.array(z.string()).optional(),
-	slug: arrayable(z.string()).optional(),
-	taxRelation: z.enum(["AND", "OR"]).optional(),
-	categories: arrayable(NumberLike).optional(),
-	categoriesExclude: arrayable(NumberLike).optional(),
-	tags: arrayable(NumberLike).optional(),
-	tagsExclude: arrayable(NumberLike).optional(),
-	sticky: BooleanLike.optional()
+	page: NumberLike.pipe(z.number().int().min(1)).catch(1).optional(),
+	perPage: lenient(NumberLike.pipe(z.number().int().min(1).max(100))),
+	search: lenient(z.string()),
+	after: lenient(z.string()),
+	before: lenient(z.string()),
+	modifiedAfter: lenient(z.string()),
+	modifiedBefore: lenient(z.string()),
+	author: lenient(arrayable(NumberLike)),
+	authorExclude: lenient(arrayable(NumberLike)),
+	exclude: lenient(arrayable(NumberLike)),
+	include: lenient(arrayable(NumberLike)),
+	offset: lenient(NumberLike.pipe(z.number().int().min(0))),
+	order: lenient(ListOrder),
+	orderby: lenient(PostOrderBy),
+	searchColumns: lenient(z.array(PostSearchColumn)),
+	slug: lenient(arrayable(z.string())),
+	taxRelation: lenient(z.enum(WP_POST_TAX_RELATIONS)),
+	categories: lenient(arrayable(NumberLike)),
+	categoriesExclude: lenient(arrayable(NumberLike)),
+	tags: lenient(arrayable(NumberLike)),
+	tagsExclude: lenient(arrayable(NumberLike)),
+	sticky: lenient(BooleanLike)
 });
 
 //#endregion

package/dist/post/utils.js

@@ -1,39 +1,42 @@
 import { deserializeSeo } from "../seo/utils.js";
-import { stringifiedMetaRecord } from "@kizlo/shared";
+import { resolveWpTimestamp, stringifiedMetaRecord } from "@kizlo/shared";
 
 //#region src/post/utils.ts
-function deserializePost(data) {
+function deserializePost(data, options) {
+	const locked = data.password.length > 0;
+	const kizlo = data.kizlo;
+	const title = data.title.rendered;
 	return {
 		id: data.id,
-		title: data.title.rendered,
-		content: !data.password.length ? data.content?.rendered ?? null : null,
-		excerpt: !data.password.length ? data.excerpt.rendered : null,
-		protected: !!data.password.length,
-		featuredMedia: data.kizlo?.featured_media ? {
-			id: data.kizlo.featured_media.id,
-			alt: data.kizlo.featured_media.alt,
-			name: data.title.rendered,
-			src: data.kizlo.featured_media.url
-		} : null,
+		url: kizlo.url ?? null,
+		parent: data.parent ?? null,
+		title: title.length > 0 ? title : null,
+		content: locked ? null : data.content?.rendered ?? null,
+		excerpt: locked ? null : data.excerpt?.rendered ?? null,
+		protected: locked,
+		preview: options?.preview ?? false,
+		status: data.status === "trash" ? "draft" : data.status,
+		featuredMedia: kizlo.featured_media ?? null,
 		commentsEnabled: data.comment_status === "open",
 		slug: data.slug,
 		sticky: data.sticky ?? false,
-		tags: data.kizlo.tags ?? [],
-		categories: data.kizlo.categories ?? [],
-		author: data.kizlo.author ? {
-			id: data.kizlo.author.id,
-			name: data.kizlo.author.name,
-			avatar: data.kizlo.author.avatar_url ? {
+		tags: kizlo.tags ?? [],
+		categories: kizlo.categories ?? [],
+		author: kizlo.author ? {
+			id: kizlo.author.id,
+			name: kizlo.author.name,
+			slug: kizlo.author.slug,
+			avatar: kizlo.author.avatar_url ? {
 				id: 0,
-				alt: data.kizlo.author.name,
-				name: data.kizlo.author.name,
-				src: data.kizlo.author.avatar_url
+				alt: kizlo.author.name,
+				name: kizlo.author.name,
+				src: kizlo.author.avatar_url
 			} : null
 		} : null,
 		format: data.format ?? "standard",
-		seo: data.kizlo.seo ? deserializeSeo(data.kizlo.seo) : null,
-		createdAt: new Date(data.date ?? "").getTime(),
-		updatedAt: new Date(data.modified ?? "").getTime(),
+		seo: kizlo.seo ? deserializeSeo(kizlo.seo) : null,
+		createdAt: resolveWpTimestamp(data.date_gmt) ?? resolveWpTimestamp(data.modified_gmt) ?? 0,
+		updatedAt: resolveWpTimestamp(data.modified_gmt) ?? 0,
 		meta: stringifiedMetaRecord(data.meta ?? {})
 	};
 }