kizlo 0.1.0 → 0.2.0

package/dist/webhook/index.d.ts

@@ -1,31 +1,32 @@
-import { WebhookEvent } from "./schema.js";
+import { KizloEvent } from "./schema.js";
 import { DefinedErrorMapLike } from "../shared/error.js";
 import { ServerContext } from "../context.js";
 import { Procedure } from "../shared/procedure.js";
 import "../index.js";
-import { Pathname, Schema, SchemaOutput } from "@kizlo/shared";
+import { Schema, SchemaOutput } from "@kizlo/shared";
 
 //#region src/webhook/index.d.ts
-type AnyWebhookEventSchema<TData = unknown> = Schema<unknown, TData>;
-type AnyWebhookEvents = {
+type AnyEventSchema<TData = unknown> = Schema<unknown, TData>;
+type AnyEvents = {
+  /** Event type strings this entry matches, e.g. `["review.created"]`. The handler's `event.type` is narrowed to this union. */
   types: string[];
-  data: AnyWebhookEventSchema;
+  /** Standard Schema that validates and types each matched event's `data` payload. */
+  data: AnyEventSchema;
 }[];
-type InferWebhookEventUnion<T extends AnyWebhookEvents> = { [K in keyof T]: {
+type InferEventUnion<T extends AnyEvents> = { [K in keyof T]: {
   type: T[K]["types"][number];
   data: SchemaOutput<T[K]["data"]>;
 } }[number];
-type WebhookHandlerFn<T extends AnyWebhookEvents> = (event: InferWebhookEventUnion<T> | WebhookEvent | null, context: ServerContext) => Promise<void> | void;
+type EventHandlerFn<T extends AnyEvents> = (event: InferEventUnion<T> | KizloEvent | null, context: ServerContext) => Promise<void> | void;
 interface WebhookOptions {
-  path?: Pathname;
   events?: EventHandler[];
 }
 interface EventHandler {
-  events?: AnyWebhookEvents;
-  handler: WebhookHandlerFn<AnyWebhookEvents>;
+  events?: AnyEvents;
+  handler: EventHandlerFn<AnyEvents>;
 }
-declare function createEventHandler<const T extends AnyWebhookEvents = never>(handler: WebhookHandlerFn<T>): EventHandler;
-declare function createEventHandler<const T extends AnyWebhookEvents = never>(events: T, handler: WebhookHandlerFn<T>): EventHandler;
+declare function createEventHandler<const T extends AnyEvents = never>(handler: EventHandlerFn<T>): EventHandler;
+declare function createEventHandler<const T extends AnyEvents = never>(events: T, handler: EventHandlerFn<T>): EventHandler;
 declare function createWebhookRouter(options?: WebhookOptions): {
   webhooks: Procedure<"api", {
     body: {
@@ -35,4 +36,4 @@ declare function createWebhookRouter(options?: WebhookOptions): {
   }, unknown, DefinedErrorMapLike>;
 };
 //#endregion
-export { AnyWebhookEventSchema, AnyWebhookEvents, EventHandler, InferWebhookEventUnion, WebhookHandlerFn, WebhookOptions, createEventHandler, createWebhookRouter };
+export { AnyEventSchema, AnyEvents, EventHandler, EventHandlerFn, InferEventUnion, WebhookOptions, createEventHandler, createWebhookRouter };

package/dist/webhook/index.js

@@ -1,7 +1,7 @@
 import { KizloError } from "../shared/error.js";
 import { createProcedure } from "../shared/procedure.js";
-import { AnyWebhookEvent } from "./schema.js";
-import { validateWebhookEvent } from "./utils.js";
+import { AnyEvent } from "./schema.js";
+import { validateEvent } from "./utils.js";
 import { tryCatchSync, verifyWebhook } from "@kizlo/shared";
 import z from "zod";
 
@@ -19,8 +19,8 @@ function createWebhookRouter(options) {
 	return { webhooks: createProcedure({
 		scope: "api",
 		method: "POST",
-		body: AnyWebhookEvent,
-		path: options?.path ?? "/webhooks",
+		body: AnyEvent,
+		path: "/webhooks",
 		output: z.void()
 	}, async ({ context, input }) => {
 		const payload = await context.request?.text() ?? "";
@@ -32,7 +32,7 @@ function createWebhookRouter(options) {
 		}));
 		if (err) throw new KizloError("FORBIDDEN", { message: "Signature verification failed." });
 		const results = await Promise.allSettled((options?.events ?? []).map(async ({ events, handler }) => {
-			const event = await validateWebhookEvent(events, input.body);
+			const event = await validateEvent(events, input.body);
 			if (!event) return;
 			await handler(event, context);
 		}));

package/dist/webhook/schema.d.ts

@@ -2,7 +2,7 @@ import z from "zod/v4";
 
 //#region src/webhook/schema.d.ts
 
-declare const WebhookEvent: z.ZodUnion<readonly [z.ZodObject<{
+declare const KizloEvent: z.ZodUnion<readonly [z.ZodObject<{
   type: z.ZodEnum<{
     "post.created": "post.created";
     "post.updated": "post.updated";
@@ -40,6 +40,6 @@ declare const WebhookEvent: z.ZodUnion<readonly [z.ZodObject<{
   }>;
   data: z.ZodNull;
 }, z.core.$strip>]>;
-type WebhookEvent = z.infer<typeof WebhookEvent>;
+type KizloEvent = z.infer<typeof KizloEvent>;
 //#endregion
-export { WebhookEvent };
+export { KizloEvent };

package/dist/webhook/schema.js

@@ -1,72 +1,72 @@
 import z from "zod/v4";
 
 //#region src/webhook/schema.ts
-const TERM_WEBHOOK_EVENT_TYPES = [
+const TERM_EVENT_TYPES = [
 	"term.created",
 	"term.updated",
 	"term.deleted"
 ];
-const TermWebhookEventType = z.enum(TERM_WEBHOOK_EVENT_TYPES);
-const POST_WEBHOOK_EVENT_TYPES = [
+const TermEventType = z.enum(TERM_EVENT_TYPES);
+const POST_EVENT_TYPES = [
 	"post.created",
 	"post.updated",
 	"post.trashed",
 	"post.deleted"
 ];
-const PostWebhookEventType = z.enum(POST_WEBHOOK_EVENT_TYPES);
-const PAYMENT_WEBHOOK_EVENT_TYPES = ["payment.status_requested"];
-const PaymentWebhookEventType = z.enum(PAYMENT_WEBHOOK_EVENT_TYPES);
-const SETTINGS_WEBHOOK_EVENT_TYPES = ["settings.saved"];
-const SettingsWebhookEventType = z.enum(SETTINGS_WEBHOOK_EVENT_TYPES);
-const WEBHOOK_EVENT_TYPES = [
-	...TERM_WEBHOOK_EVENT_TYPES,
-	...POST_WEBHOOK_EVENT_TYPES,
-	...PAYMENT_WEBHOOK_EVENT_TYPES,
-	...SETTINGS_WEBHOOK_EVENT_TYPES
+const PostEventType = z.enum(POST_EVENT_TYPES);
+const PAYMENT_EVENT_TYPES = ["payment.status_requested"];
+const PaymentEventType = z.enum(PAYMENT_EVENT_TYPES);
+const SETTINGS_EVENT_TYPES = ["settings.saved"];
+const SettingsEventType = z.enum(SETTINGS_EVENT_TYPES);
+const EVENT_TYPES = [
+	...TERM_EVENT_TYPES,
+	...POST_EVENT_TYPES,
+	...PAYMENT_EVENT_TYPES,
+	...SETTINGS_EVENT_TYPES
 ];
-const WebhookEventType = z.enum(WEBHOOK_EVENT_TYPES);
-const PostWebhookEventData = z.object({
+const EventType = z.enum(EVENT_TYPES);
+const PostEventData = z.object({
 	post_id: z.number(),
 	post_type: z.string()
 });
-const PostWebhookEvent = z.object({
-	type: PostWebhookEventType,
-	data: PostWebhookEventData
+const PostEvent = z.object({
+	type: PostEventType,
+	data: PostEventData
 });
-const TermWebhookEventData = z.object({
+const TermEventData = z.object({
 	term_id: z.number(),
 	taxonomy: z.string(),
 	post_types: z.array(z.string()),
 	count: z.number().nonnegative()
 });
-const TermWebhookEvent = z.object({
-	type: TermWebhookEventType,
-	data: TermWebhookEventData
+const TermEvent = z.object({
+	type: TermEventType,
+	data: TermEventData
 });
-const PaymentWebhookEventData = z.object({
+const PaymentEventData = z.object({
 	transaction_id: z.nullable(z.string()),
 	payment_method_id: z.string(),
 	payment_session_id: z.string()
 });
-const PaymentWebhookEvent = z.object({
-	type: PaymentWebhookEventType,
-	data: PaymentWebhookEventData
+const PaymentEvent = z.object({
+	type: PaymentEventType,
+	data: PaymentEventData
 });
-const SettingsWebhookEventData = z.null();
-const SettingsWebhookEvent = z.object({
-	type: SettingsWebhookEventType,
-	data: SettingsWebhookEventData
+const SettingsEventData = z.null();
+const SettingsEvent = z.object({
+	type: SettingsEventType,
+	data: SettingsEventData
 });
-const WebhookEvent = z.union([
-	PostWebhookEvent,
-	TermWebhookEvent,
-	PaymentWebhookEvent,
-	SettingsWebhookEvent
+const KizloEvent = z.union([
+	PostEvent,
+	TermEvent,
+	PaymentEvent,
+	SettingsEvent
 ]);
-const AnyWebhookEvent = z.object({
+const AnyEvent = z.object({
 	type: z.string(),
 	data: z.unknown()
 });
 
 //#endregion
-export { AnyWebhookEvent, WebhookEvent };
+export { AnyEvent, KizloEvent };

package/dist/webhook/utils.js

@@ -1,9 +1,9 @@
-import { WebhookEvent } from "./schema.js";
+import { KizloEvent } from "./schema.js";
 import { safeValidateSchema } from "@kizlo/shared";
 
 //#region src/webhook/utils.ts
-async function validateWebhookEvent(events, data) {
-	const internal = await safeValidateSchema(WebhookEvent, data);
+async function validateEvent(events, data) {
+	const internal = await safeValidateSchema(KizloEvent, data);
 	if (internal.success) return internal.value;
 	const external = events?.find((a) => a.types.includes(data.type))?.data;
 	if (external) {
@@ -18,4 +18,4 @@ async function validateWebhookEvent(events, data) {
 }
 
 //#endregion
-export { validateWebhookEvent };
+export { validateEvent };

package/dist/wordpress/service.js

@@ -104,6 +104,12 @@ var WordPressService = class {
 				message: readErr.message
 			})
 		};
+		if (response.ok && text.trim() === "") return {
+			data: null,
+			status: response.status,
+			headers: response.headers,
+			error: null
+		};
 		const [parseErr, data] = tryCatchSync(() => JSON.parse(text));
 		if (!response.ok) {
 			if (isWordPressResourceError(data)) return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizlo",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "A headless WordPress toolkit for TypeScript.",
   "keywords": [
@@ -76,7 +76,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.5.1",
-    "@kizlo/shared": "0.1.0",
+    "@kizlo/shared": "0.1.1",
     "@orpc/client": "^1.14.3",
     "@orpc/contract": "^1.14.3",
     "@orpc/openapi": "^1.14.3",

package/dist/cli/commands/wp.js

@@ -1,66 +0,0 @@
-import { isSeeded } from "../wp/utils.js";
-import { composeDown, composeStop, composeUp } from "../wp/docker.js";
-import { withSpinner } from "../utils.js";
-import { log } from "../daemon/logger.js";
-import { resolveTestConfig } from "../daemon/config.js";
-import { runSeeds } from "../wp/setup.js";
-import { defineCommand } from "citty";
-
-//#region src/cli/commands/wp.ts
-/** Boot the stack and seed it once (idempotent — skips seeding if already seeded). */
-async function bringUp(cwd) {
-	const cfg = await resolveTestConfig(cwd);
-	process.env.WP_PORT = String(cfg.port);
-	await withSpinner("Starting WordPress test stack", composeUp, "WordPress test stack ready");
-	if (await isSeeded()) {
-		log.info("Stack already seeded — skipping seed.");
-		return;
-	}
-	await withSpinner("Seeding WordPress", () => runSeeds({
-		port: cfg.port,
-		fixtures: cfg.fixtures
-	}), "WordPress seeded");
-	log.success(`Stack ready on http://localhost:${cfg.port} — credentials at ${cfg.credentialsPath}`);
-}
-const up = defineCommand({
-	meta: {
-		name: "up",
-		description: "Start the WordPress test stack and seed it if needed"
-	},
-	async run() {
-		await bringUp(process.cwd());
-	}
-});
-const reset = defineCommand({
-	meta: {
-		name: "reset",
-		description: "Wipe the database and reseed a fresh WordPress test stack"
-	},
-	async run() {
-		await withSpinner("Wiping WordPress database", () => composeDown({ volumes: true }), "Database wiped");
-		await bringUp(process.cwd());
-	}
-});
-const stop = defineCommand({
-	meta: {
-		name: "stop",
-		description: "Stop the WordPress test stack, keeping the database volume"
-	},
-	async run() {
-		await withSpinner("Stopping WordPress test stack", composeStop, "Stack stopped (volumes kept)");
-	}
-});
-const wp = defineCommand({
-	meta: {
-		name: "wp",
-		description: "Manage the WordPress test stack (advanced: up | reset | stop)"
-	},
-	subCommands: {
-		up,
-		reset,
-		stop
-	}
-});
-
-//#endregion
-export { wp };