kizlo 0.1.0

package/dist/seo/index.js

@@ -0,0 +1,54 @@
+import { createProcedure } from "../shared/procedure.js";
+import { WP_KIZLO_BASE } from "../wordpress/constants.js";
+import { ListSitemapUrlInput, Robots, SitemapList, SitemapUrlList } from "./schema.js";
+
+//#region src/seo/index.ts
+const SEO_ROUTER_MAP = {
+	sitemaps: createProcedure({
+		scope: "internal",
+		output: SitemapList
+	}, async ({ context, errors }) => {
+		const response = await context.service.wordpress.get("/seo/sitemaps", { base: WP_KIZLO_BASE });
+		if (response.error) {
+			context.logger.error("List sitemaps unhandled error", response.error);
+			throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return response.data;
+	}),
+	robots: createProcedure({
+		scope: "internal",
+		output: Robots
+	}, async ({ context, errors }) => {
+		const response = await context.service.wordpress.get(`/seo/robots`, { base: WP_KIZLO_BASE });
+		if (response.error) {
+			context.logger.error("List robots unhandled error", response.error);
+			throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return {
+			sitemaps: response.data.sitemaps ?? [],
+			rules: response.data.rules.map((item) => ({
+				allow: item.allow,
+				disallow: item.disallow,
+				userAgent: item.user_agent
+			}))
+		};
+	}),
+	urls: createProcedure({
+		scope: "internal",
+		output: SitemapUrlList,
+		input: ListSitemapUrlInput
+	}, async ({ context, input, errors }) => {
+		const response = await context.service.wordpress.get(`/seo/sitemaps/${input.type}/${input.type !== "author" ? input.key : ""}`, {
+			base: WP_KIZLO_BASE,
+			searchParams: { page: input.page ?? 1 }
+		});
+		if (response.error) {
+			context.logger.error("List sitemap urls unhandled error", response.error);
+			throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return response.data;
+	})
+};
+
+//#endregion
+export { SEO_ROUTER_MAP };

package/dist/seo/schema.d.ts

@@ -0,0 +1,196 @@
+import z from "zod/v4";
+
+//#region src/seo/schema.d.ts
+declare const SeoHead: z.ZodObject<{
+  title: z.ZodString;
+  canonical: z.ZodString;
+  robots: z.ZodObject<{
+    index: z.ZodString;
+    follow: z.ZodString;
+    maxSnippet: z.ZodString;
+    maxImagePreview: z.ZodString;
+    maxVideoPreview: z.ZodString;
+  }, z.core.$strip>;
+  og: z.ZodObject<{
+    locale: z.ZodString;
+    type: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodString;
+    siteName: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodNullable<z.ZodObject<{
+      url: z.ZodString;
+      width: z.ZodString;
+      height: z.ZodString;
+      type: z.ZodString;
+      alt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  twitter: z.ZodObject<{
+    card: z.ZodEnum<{
+      summary: "summary";
+      summary_large_image: "summary_large_image";
+    }>;
+    title: z.ZodString;
+    site: z.ZodNullable<z.ZodString>;
+    creator: z.ZodNullable<z.ZodString>;
+    description: z.ZodString;
+    image: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  article: z.ZodNullable<z.ZodObject<{
+    publishedTime: z.ZodString;
+    modifiedTime: z.ZodString;
+    author: z.ZodString;
+    authorUrl: z.ZodString;
+    section: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SeoHead = z.infer<typeof SeoHead>;
+declare const SeoSchema: z.ZodObject<{
+  "@context": z.ZodLiteral<"https://schema.org">;
+  "@graph": z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type SeoSchema = z.infer<typeof SeoSchema>;
+declare const Seo: z.ZodObject<{
+  head: z.ZodObject<{
+    title: z.ZodString;
+    canonical: z.ZodString;
+    robots: z.ZodObject<{
+      index: z.ZodString;
+      follow: z.ZodString;
+      maxSnippet: z.ZodString;
+      maxImagePreview: z.ZodString;
+      maxVideoPreview: z.ZodString;
+    }, z.core.$strip>;
+    og: z.ZodObject<{
+      locale: z.ZodString;
+      type: z.ZodString;
+      title: z.ZodString;
+      url: z.ZodString;
+      siteName: z.ZodString;
+      description: z.ZodString;
+      image: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        width: z.ZodString;
+        height: z.ZodString;
+        type: z.ZodString;
+        alt: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    twitter: z.ZodObject<{
+      card: z.ZodEnum<{
+        summary: "summary";
+        summary_large_image: "summary_large_image";
+      }>;
+      title: z.ZodString;
+      site: z.ZodNullable<z.ZodString>;
+      creator: z.ZodNullable<z.ZodString>;
+      description: z.ZodString;
+      image: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    article: z.ZodNullable<z.ZodObject<{
+      publishedTime: z.ZodString;
+      modifiedTime: z.ZodString;
+      author: z.ZodString;
+      authorUrl: z.ZodString;
+      section: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  schema: z.ZodObject<{
+    "@context": z.ZodLiteral<"https://schema.org">;
+    "@graph": z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type Seo = z.infer<typeof Seo>;
+declare const CONTENT_TYPES: readonly ["post_type", "taxonomy", "author"];
+declare const ContentType: z.ZodEnum<{
+  author: "author";
+  post_type: "post_type";
+  taxonomy: "taxonomy";
+}>;
+type ContentType = z.infer<typeof ContentType>;
+declare const Sitemap: z.ZodObject<{
+  key: z.ZodString;
+  type: z.ZodEnum<{
+    author: "author";
+    post_type: "post_type";
+    taxonomy: "taxonomy";
+  }>;
+  pages: z.ZodNumber;
+  lastmod: z.ZodString;
+}, z.core.$strip>;
+type Sitemap = z.infer<typeof Sitemap>;
+declare const SitemapList: z.ZodArray<z.ZodObject<{
+  key: z.ZodString;
+  type: z.ZodEnum<{
+    author: "author";
+    post_type: "post_type";
+    taxonomy: "taxonomy";
+  }>;
+  pages: z.ZodNumber;
+  lastmod: z.ZodString;
+}, z.core.$strip>>;
+type SitemapList = z.infer<typeof SitemapList>;
+declare const SitemapUrlImage: z.ZodObject<{
+  loc: z.ZodString;
+  title: z.ZodString;
+}, z.core.$strip>;
+type SitemapUrlImage = z.infer<typeof SitemapUrlImage>;
+declare const SitemapUrl: z.ZodObject<{
+  loc: z.ZodString;
+  lastmod: z.ZodString;
+  images: z.ZodArray<z.ZodObject<{
+    loc: z.ZodString;
+    title: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SitemapUrl = z.infer<typeof SitemapUrl>;
+declare const SitemapUrlList: z.ZodArray<z.ZodObject<{
+  loc: z.ZodString;
+  lastmod: z.ZodString;
+  images: z.ZodArray<z.ZodObject<{
+    loc: z.ZodString;
+    title: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+type SitemapUrlList = z.infer<typeof SitemapUrlList>;
+declare const ListSitemapUrlInputBase: z.ZodObject<{
+  type: z.ZodEnum<{
+    author: "author";
+    post_type: "post_type";
+    taxonomy: "taxonomy";
+  }>;
+  page: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodCoercedNumber<string | number>>>;
+}, z.core.$strip>;
+type ListSitemapUrlInputBase = z.input<typeof ListSitemapUrlInputBase>;
+declare const ListSitemapUrlInput: z.ZodUnion<readonly [z.ZodObject<{
+  page: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodCoercedNumber<string | number>>>;
+  type: z.ZodEnum<{
+    post_type: "post_type";
+    taxonomy: "taxonomy";
+  }>;
+  key: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  page: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodCoercedNumber<string | number>>>;
+  type: z.ZodEnum<{
+    author: "author";
+  }>;
+}, z.core.$strip>]>;
+type ListSitemapUrlInput = z.infer<typeof ListSitemapUrlInput>;
+declare const RobotsRule: z.ZodObject<{
+  userAgent: z.ZodString;
+  allow: z.ZodArray<z.ZodString>;
+  disallow: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type RobotsRule = z.infer<typeof RobotsRule>;
+declare const Robots: z.ZodObject<{
+  sitemaps: z.ZodArray<z.ZodString>;
+  rules: z.ZodArray<z.ZodObject<{
+    userAgent: z.ZodString;
+    allow: z.ZodArray<z.ZodString>;
+    disallow: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Robots = z.infer<typeof Robots>;
+//#endregion
+export { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList };

package/dist/seo/schema.js

@@ -0,0 +1,96 @@
+import { NumberLike } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/seo/schema.ts
+const SeoHead = z.object({
+	title: z.string(),
+	canonical: z.string(),
+	robots: z.object({
+		index: z.string(),
+		follow: z.string(),
+		maxSnippet: z.string(),
+		maxImagePreview: z.string(),
+		maxVideoPreview: z.string()
+	}),
+	og: z.object({
+		locale: z.string(),
+		type: z.string(),
+		title: z.string(),
+		url: z.string(),
+		siteName: z.string(),
+		description: z.string(),
+		image: z.object({
+			url: z.string(),
+			width: z.string(),
+			height: z.string(),
+			type: z.string(),
+			alt: z.string().nullable()
+		}).nullable()
+	}),
+	twitter: z.object({
+		card: z.enum(["summary", "summary_large_image"]),
+		title: z.string(),
+		site: z.string().nullable(),
+		creator: z.string().nullable(),
+		description: z.string(),
+		image: z.string().nullable()
+	}),
+	article: z.object({
+		publishedTime: z.string(),
+		modifiedTime: z.string(),
+		author: z.string(),
+		authorUrl: z.string(),
+		section: z.string()
+	}).nullable()
+});
+const SeoSchema = z.object({
+	"@context": z.literal("https://schema.org"),
+	"@graph": z.array(z.record(z.string(), z.unknown()))
+});
+const Seo = z.object({
+	head: SeoHead,
+	schema: SeoSchema
+});
+const CONTENT_TYPES = [
+	"post_type",
+	"taxonomy",
+	"author"
+];
+const ContentType = z.enum(CONTENT_TYPES);
+const Sitemap = z.object({
+	key: z.string(),
+	type: ContentType,
+	pages: z.number(),
+	lastmod: z.string()
+});
+const SitemapList = z.array(Sitemap);
+const SitemapUrlImage = z.object({
+	loc: z.string(),
+	title: z.string()
+});
+const SitemapUrl = z.object({
+	loc: z.string(),
+	lastmod: z.string(),
+	images: z.array(SitemapUrlImage)
+});
+const SitemapUrlList = z.array(SitemapUrl);
+const ListSitemapUrlInputBase = z.object({
+	type: ContentType,
+	page: NumberLike.optional()
+});
+const ListSitemapUrlInput = z.union([ListSitemapUrlInputBase.extend({
+	type: ContentType.exclude(["author"]),
+	key: z.string()
+}), ListSitemapUrlInputBase.extend({ type: ContentType.extract(["author"]) })]);
+const RobotsRule = z.object({
+	userAgent: z.string(),
+	allow: z.array(z.string()),
+	disallow: z.array(z.string())
+});
+const Robots = z.object({
+	sitemaps: z.array(z.string()),
+	rules: z.array(RobotsRule)
+});
+
+//#endregion
+export { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList };

package/dist/seo/types.d.ts

@@ -0,0 +1,80 @@
+//#region src/seo/types.d.ts
+interface WPK_Seo {
+  head: {
+    title: string;
+    canonical: string;
+    robots: {
+      index: string;
+      follow: string;
+      "max-snippet": string;
+      "max-image-preview": string;
+      "max-video-preview": string;
+    };
+    og: {
+      locale: string;
+      type: string;
+      title: string;
+      url: string;
+      site_name: string;
+      description: string;
+      image: {
+        url: string;
+        width: string;
+        height: string;
+        type: string;
+        alt: string | null;
+      } | null;
+    };
+    twitter: {
+      card: "summary_large_image";
+      title: string;
+      site: string | null;
+      creator: string | null;
+      description: string;
+      image: string | null;
+    };
+    article: {
+      published_time: string;
+      modified_time: string;
+      author: string;
+      author_url: string;
+      section: string;
+    } | null;
+  };
+  schema: {
+    "@context": "https://schema.org";
+    "@graph": Record<string, unknown>[];
+  };
+}
+type WPK_SitemapContentType = "post_type" | "taxonomy" | "author";
+interface WPK_RobotRule {
+  user_agent: string;
+  allow: string[];
+  disallow: string[];
+}
+interface WPK_Robots {
+  rules: WPK_RobotRule[];
+  sitemaps?: string[];
+}
+interface WPK_Sitemap {
+  key: string;
+  type: WPK_SitemapContentType;
+  pages: number;
+  lastmod: string;
+}
+interface WPK_SitemapUrlImage {
+  loc: string;
+  title: string;
+}
+interface WPK_SitemapUrl {
+  loc: string;
+  lastmod: string;
+  images: WPK_SitemapUrlImage[];
+}
+interface WPK_ListSitemapUrlInput {
+  type: WPK_SitemapContentType;
+  key?: string;
+  page?: number;
+}
+//#endregion
+export { WPK_ListSitemapUrlInput, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapUrl, WPK_SitemapUrlImage };

package/dist/seo/utils.js

@@ -0,0 +1,44 @@
+//#region src/seo/utils.ts
+function deserializeSeo(data) {
+	return {
+		head: {
+			article: data.head.article ? {
+				author: data.head.article.author,
+				authorUrl: data.head.article.author_url,
+				modifiedTime: data.head.article.modified_time,
+				publishedTime: data.head.article.published_time,
+				section: data.head.article.section
+			} : null,
+			canonical: data.head.canonical,
+			og: {
+				description: data.head.og.description,
+				image: data.head.og.image ?? null,
+				locale: data.head.og.locale,
+				siteName: data.head.og.site_name,
+				title: data.head.og.title,
+				type: data.head.og.type,
+				url: data.head.og.url
+			},
+			robots: {
+				index: data.head.robots.index,
+				follow: data.head.robots.follow,
+				maxSnippet: data.head.robots["max-snippet"],
+				maxImagePreview: data.head.robots["max-image-preview"],
+				maxVideoPreview: data.head.robots["max-video-preview"]
+			},
+			title: data.head.title,
+			twitter: {
+				card: data.head.twitter.card,
+				creator: data.head.twitter.creator,
+				description: data.head.twitter.description,
+				image: data.head.twitter.image ?? null,
+				site: data.head.twitter.site,
+				title: data.head.twitter.title
+			}
+		},
+		schema: data.schema
+	};
+}
+
+//#endregion
+export { deserializeSeo };

package/dist/service.d.ts

@@ -0,0 +1,17 @@
+import { WordPressCredentials } from "./wordpress/types.js";
+import { WordPressService } from "./wordpress/service.js";
+import "./wordpress/index.js";
+import { EmailService } from "./email/service.js";
+
+//#region src/service.d.ts
+interface ServiceConfig {
+  credentials: WordPressCredentials;
+}
+declare class Service {
+  readonly email: EmailService;
+  readonly wordpress: WordPressService;
+  private readonly config;
+  constructor(config: ServiceConfig);
+}
+//#endregion
+export { Service, ServiceConfig };

package/dist/service.js

@@ -0,0 +1,17 @@
+import { WordPressService } from "./wordpress/service.js";
+import { EmailService } from "./email/service.js";
+
+//#region src/service.ts
+var Service = class {
+	email;
+	wordpress;
+	config;
+	constructor(config) {
+		this.config = config;
+		this.email = new EmailService(this);
+		this.wordpress = new WordPressService(this.config);
+	}
+};
+
+//#endregion
+export { Service };

package/dist/shared/constants.js

@@ -0,0 +1,10 @@
+import { version } from "../package.js";
+import { milliseconds } from "@kizlo/shared";
+
+//#region src/shared/constants.ts
+const VERSION = version;
+const RPC_PROTOCOL_HEADER = "x-rpc-protocol";
+const SESSION_EXPIRY_MARGIN_MS = milliseconds("5 minutes");
+
+//#endregion
+export { RPC_PROTOCOL_HEADER };

package/dist/shared/contract.d.ts

@@ -0,0 +1,21 @@
+import { HTTPMethod } from "./types.js";
+import { AnyProcedureRouter, InvocationScope } from "./procedure.js";
+import { AnyContractRouter } from "@orpc/contract";
+import { Pathname } from "@kizlo/shared";
+
+//#region src/shared/contract.d.ts
+type Contract = {
+  [key: string]: ContractProcedure | Contract;
+};
+type ContractProcedure = {
+  scope: InvocationScope;
+  route: {
+    method?: HTTPMethod;
+    path?: Pathname;
+  };
+};
+declare function isContractProcedure$1(node: unknown): node is ContractProcedure;
+declare function generateContract<TRouter extends AnyProcedureRouter>(router: TRouter): Promise<Contract>;
+declare function restoreContract(contract: Contract): AnyContractRouter;
+//#endregion
+export { Contract, ContractProcedure, generateContract, isContractProcedure$1 as isContractProcedure, restoreContract };

package/dist/shared/contract.js

@@ -0,0 +1,43 @@
+import { createOrpcRouter } from "./router.js";
+import { isContractProcedure, minifyContractRouter } from "@orpc/contract";
+
+//#region src/shared/contract.ts
+function isContractProcedure$1(node) {
+	if (!node || typeof node !== "object") return false;
+	return "route" in node || "meta" in node;
+}
+async function generateContract(router) {
+	const contract = minifyContractRouter(createOrpcRouter(router));
+	const walk = (node) => {
+		const out = {};
+		for (const [key, value] of Object.entries(node)) if (isContractProcedure(value)) {
+			const { route, meta } = value["~orpc"];
+			const scope = meta?.scope ?? null;
+			if (!scope) throw new Error("Scope not defined in procedure metadata.");
+			out[key] = {
+				scope,
+				route: route ?? {}
+			};
+		} else out[key] = walk(value);
+		return out;
+	};
+	return walk(contract);
+}
+function restoreContract(contract) {
+	const walk = (node) => {
+		const out = {};
+		for (const [key, value] of Object.entries(node)) if (isContractProcedure$1(value)) {
+			const procedure = value;
+			out[key] = { "~orpc": {
+				meta: {},
+				errorMap: {},
+				route: procedure.route ?? {}
+			} };
+		} else out[key] = walk(value);
+		return out;
+	};
+	return walk(contract);
+}
+
+//#endregion
+export { generateContract, isContractProcedure$1 as isContractProcedure, restoreContract };

package/dist/shared/crypto.d.ts

@@ -0,0 +1,28 @@
+import { BinaryLike } from "node:crypto";
+
+//#region src/shared/crypto.d.ts
+
+/**
+ * Compares two strings in a timing-safe manner to prevent timing attacks.
+ *
+ * @param a - The first string to compare.
+ * @param b - The second string to compare.
+ * @returns `true` if the strings match, `false` otherwise.
+ */
+declare function compare(a: string, b: string): boolean;
+/**
+ * Hashes a secret API key with SHA-256 for secure database storage.
+ * Safe to use in place of bcrypt/argon2 because API keys are high-entropy
+ * random strings, unlike user-chosen passwords.
+ * Only secret keys should be hashed — publishable keys are not sensitive.
+ *
+ * @param key - The raw secret API key to hash.
+ * @returns A SHA-256 hex string suitable for database storage.
+ */
+declare function hash(key: string): string;
+/**
+ * Create hmac using node crypto lib.
+ */
+declare function hmac(key: string, value: BinaryLike): string;
+//#endregion
+export { compare, hash, hmac };

package/dist/shared/crypto.js

@@ -0,0 +1,34 @@
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+
+//#region src/shared/crypto.ts
+/**
+* Compares two strings in a timing-safe manner to prevent timing attacks.
+*
+* @param a - The first string to compare.
+* @param b - The second string to compare.
+* @returns `true` if the strings match, `false` otherwise.
+*/
+function compare(a, b) {
+	return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+/**
+* Hashes a secret API key with SHA-256 for secure database storage.
+* Safe to use in place of bcrypt/argon2 because API keys are high-entropy
+* random strings, unlike user-chosen passwords.
+* Only secret keys should be hashed — publishable keys are not sensitive.
+*
+* @param key - The raw secret API key to hash.
+* @returns A SHA-256 hex string suitable for database storage.
+*/
+function hash(key) {
+	return createHash("sha256").update(key).digest("hex");
+}
+/**
+* Create hmac using node crypto lib.
+*/
+function hmac(key, value) {
+	return createHmac("sha256", key).update(value).digest("hex");
+}
+
+//#endregion
+export { compare, hash, hmac };