kizlo 0.7.0 → 0.8.0

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 ?? {})
 	};
 }