kizlo 0.17.0 → 0.19.0

package/dist/adapters/auth.d.ts

@@ -1,27 +1,28 @@
-import { Promisify } from "@kizlo/shared";
+import { JsonValue, Promisify } from "@kizlo/shared";
 
 //#region src/adapters/auth.d.ts
 interface AuthUser {
-  /** The WordPress user id this caller maps to. */
-  id: number;
-  /** The user's email, if known. */
-  email?: string;
-  /** The user's phone number, if known. */
-  phone?: string;
-  /** The user's first name. */
-  firstName: string;
-  /** The user's last name. */
-  lastName: string;
+  /** The third-party auth id. This is the identity provider's own id, never a WordPress user id. */
+  id: string;
+  /** The user's email. The single join key that maps this session to a WordPress user. */
+  email: string;
+  /** The user's first name, if known. */
+  firstName?: string;
+  /** The user's last name, if known. */
+  lastName?: string;
+  /** Arbitrary claims the auth service carries alongside the identity. */
+  meta?: Record<string, JsonValue>;
 }
-type AuthGetUser = (request: Request | null) => Promisify<AuthUser | null>;
+type AuthGetSession = (request: Request | null) => Promisify<AuthUser | null>;
 interface AuthAdapter {
-  /** Resolve the authenticated user from the request, or `null` when there is no session. Receives `null` for server-side (non-HTTP) invocations. */
-  getUser: AuthGetUser;
+  /** Resolve the authenticated session from the request, or `null` when there is no session. Receives `null` for server-side (non-HTTP) invocations. */
+  getSession: AuthGetSession;
 }
 /** Author a custom auth adapter, typed against the {@link AuthAdapter} contract. */
 declare function createAuthAdapter(adapter: AuthAdapter): AuthAdapter;
 declare function authMock(options?: {
-  mockUserId?: number;
+  id?: string;
+  email?: string;
 }): AuthAdapter;
 //#endregion
-export { AuthAdapter, AuthGetUser, AuthUser, authMock, createAuthAdapter };
+export { AuthAdapter, AuthGetSession, AuthUser, authMock, createAuthAdapter };

package/dist/adapters/auth.js

@@ -4,13 +4,12 @@ function createAuthAdapter(adapter) {
 	return adapter;
 }
 function authMock(options) {
-	return { getUser() {
+	return { getSession() {
 		return {
-			id: options?.mockUserId ?? 0,
+			id: options?.id ?? "auth-mock-user",
+			email: options?.email ?? "karan@gmail.com",
 			firstName: "Karan",
-			lastName: "Gill",
-			email: "karan@gmail.con",
-			phone: "12345678901"
+			lastName: "Gill"
 		};
 	} };
 }

package/dist/category/index.js

@@ -1,8 +1,8 @@
-import { createProcedure } from "../shared/procedure.js";
+import { Category, CategoryList, ListCategoryInput, RetrieveCategoryInput } from "./schema.js";
+import { createProcedure, schemaType } from "../shared/procedure.js";
 import { parseIdentifier } from "../shared/identifier.js";
 import { deserializeListMetadata } from "../shared/serialize.js";
 import { GET_CATEGORY_ERROR_MAP, LIST_CATEGORY_ERROR_MAP } from "./error.js";
-import { Category, CategoryList, ListCategoryInput, RetrieveCategoryInput } from "./schema.js";
 import { deserializeCategory } from "./utils.js";
 import { normalizeArrayableValue } from "@kizlo/shared";
 
@@ -13,7 +13,7 @@ const CATEGORY_PROCEDURES = {
 		method: "GET",
 		path: "/categories/{identifier}",
 		params: RetrieveCategoryInput.pick({ identifier: true }),
-		output: Category,
+		output: schemaType(Category),
 		errors: GET_CATEGORY_ERROR_MAP
 	}, async ({ input, context, errors }) => {
 		const identifier = parseIdentifier(input.params.identifier);
@@ -38,7 +38,7 @@ const CATEGORY_PROCEDURES = {
 		method: "GET",
 		path: "/categories",
 		query: ListCategoryInput.optional(),
-		output: CategoryList,
+		output: schemaType(CategoryList),
 		errors: LIST_CATEGORY_ERROR_MAP
 	}, async ({ input, context, errors }) => {
 		const response = await context.wordpress.taxonomies.category.list({

package/dist/category/schema.d.ts

@@ -0,0 +1,153 @@
+import { WP_CustomFields } from "../wordpress/types.js";
+import "../wordpress/index.js";
+import * as _kizlo_shared0 from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/category/schema.d.ts
+type CategoryCustomFields = WP_CustomFields<"taxonomies.category">;
+declare const CategoryCustomFieldsSchema: z.ZodType<CategoryCustomFields, CategoryCustomFields>;
+declare const Category: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  slug: z.ZodString;
+  url: z.ZodNullable<z.ZodString>;
+  description: z.ZodNullable<z.ZodString>;
+  parent: z.ZodNullable<z.ZodNumber>;
+  postCount: z.ZodNumber;
+  seo: z.ZodNullable<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.ZodNullable<z.ZodNumber>;
+          height: z.ZodNullable<z.ZodNumber>;
+          type: z.ZodNullable<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>;
+        imageAlt: 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;
+        tags: z.ZodArray<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>>;
+  custom: z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>;
+  meta: z.ZodRecord<z.ZodString, z.ZodType<_kizlo_shared0.JSONValue, unknown, z.core.$ZodTypeInternals<_kizlo_shared0.JSONValue, unknown>>>;
+}, z.core.$strip>;
+type Category = Omit<z.output<typeof Category>, "custom"> & {
+  custom: CategoryCustomFields;
+};
+declare const CategoryList: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    slug: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    parent: z.ZodNullable<z.ZodNumber>;
+    postCount: z.ZodNumber;
+    seo: z.ZodNullable<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.ZodNullable<z.ZodNumber>;
+            height: z.ZodNullable<z.ZodNumber>;
+            type: z.ZodNullable<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>;
+          imageAlt: 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;
+          tags: z.ZodArray<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>>;
+    custom: z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>;
+    meta: z.ZodRecord<z.ZodString, z.ZodType<_kizlo_shared0.JSONValue, unknown, z.core.$ZodTypeInternals<_kizlo_shared0.JSONValue, unknown>>>;
+  }, z.core.$strip>>;
+  meta: z.ZodObject<{
+    page: z.ZodNumber;
+    totalItems: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    nextPage: z.ZodNullable<z.ZodNumber>;
+    prevPage: z.ZodNullable<z.ZodNumber>;
+    hasNextPage: z.ZodBoolean;
+    hasPrevPage: z.ZodBoolean;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CategoryList = Omit<z.output<typeof CategoryList>, "items"> & {
+  items: Category[];
+};
+//#endregion
+export { Category, CategoryCustomFields, CategoryCustomFieldsSchema, CategoryList };

package/dist/category/schema.js

@@ -1,5 +1,5 @@
-import { IdentifierInput, ListMetadata, ListOrder, customFieldsSchema } from "../shared/schema.js";
 import { Seo } from "../seo/schema.js";
+import { IdentifierInput, ListMetadata, ListOrder, customFieldsSchema } from "../shared/schema.js";
 import { BooleanLike, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
 import z from "zod/v4";
 
@@ -14,6 +14,7 @@ const WP_CATEGORY_ORDER_BYS = [
 	"description",
 	"count"
 ];
+const CategoryCustomFieldsSchema = customFieldsSchema();
 const Category = z.object({
 	id: z.number(),
 	name: z.string(),
@@ -23,7 +24,7 @@ const Category = z.object({
 	parent: z.number().nullable(),
 	postCount: z.number(),
 	seo: Seo.nullable(),
-	custom: customFieldsSchema(),
+	custom: CategoryCustomFieldsSchema,
 	meta: Metadata
 });
 const RetrieveCategoryInput = z.object({ identifier: IdentifierInput });
@@ -47,4 +48,4 @@ const ListCategoryInput = z.object({
 });
 
 //#endregion
-export { Category, CategoryList, ListCategoryInput, RetrieveCategoryInput };
+export { Category, CategoryCustomFieldsSchema, CategoryList, ListCategoryInput, RetrieveCategoryInput };

package/dist/cli/commands/_wiring.js

@@ -1,5 +1,5 @@
 import { aliasWithSlash, resolveModuleImport, writeFileIfAbsent } from "../utils.js";
-import { CONTRACT_BARREL, WORDPRESS_STUB } from "../daemon/generate.js";
+import { CONTRACT_BARREL, INTROSPECTION_STUB } from "../daemon/generate.js";
 import { resolvePatch } from "../presets/template.js";
 import { orCancel } from "./_setup.js";
 import { applyPatchToSource, patchChanged, renderPatchCode, resolvePatchTargetPath } from "../presets/patch.js";
@@ -8,16 +8,17 @@ import fs from "node:fs";
 import * as p from "@clack/prompts";
 
 //#region src/cli/commands/_wiring.ts
-/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, the import-alias preference, and —
-*  when local WordPress is chosen — `dev.local` + `test.local` so `kizlo dev` and `kizlo test` boot the
-*  fixed `.kizlo/local` install. The alias is always written — `""` for relative imports included — so it
-*  records a made decision a later `kizlo init` reads back instead of prompting for it again. The alias
-*  is written in its canonical `@/` form (never a bare `@`) so it reads like the imports it produces. */
+/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, the import-alias preference, and,
+*  when local WordPress is chosen, `local: true` so `kizlo dev` and `kizlo test` boot the fixed
+*  `.kizlo/local` install (both stacks on with defaults; the object form is for configuring them). The
+*  alias is always written (`""` for relative imports included) so it records a made decision a later
+*  `kizlo init` reads back instead of prompting for it again. The alias is written in its canonical `@/`
+*  form (never a bare `@`) so it reads like the imports it produces. */
 function kizloConfigTemplate(dir, alias, localWordPress = false) {
 	return `import { defineConfig } from "kizlo/config"
 
 export default defineConfig({
-	dir: "${dir}",${`\n\talias: "${aliasWithSlash(alias)}",`}${localWordPress ? `\n\tdev: { local: true },\n\ttest: { local: true },` : ""}
+	dir: "${dir}",${`\n\talias: "${aliasWithSlash(alias)}",`}${localWordPress ? `\n\tlocal: true,` : ""}
 })
 `;
 }
@@ -77,7 +78,7 @@ function writeGeneratedContract(cwd, serverDirRel) {
 	const generatedDirRel = path.join(serverDirRel, "generated");
 	writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
 	writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
-	writeFileIfAbsent(path.join(cwd, generatedDirRel, "wordpress.ts"), WORDPRESS_STUB);
+	writeFileIfAbsent(path.join(cwd, generatedDirRel, "introspection.ts"), INTROSPECTION_STUB);
 }
 /**
 * Apply every patch a template declares, merging Kizlo wiring into files the project already owns

package/dist/cli/commands/check.js

@@ -1,6 +1,6 @@
 import { log } from "../daemon/logger.js";
-import { resolveConfig, resolveWordPressClientDir } from "../daemon/config.js";
-import { generateWordPressSource, reportGenerationError } from "../daemon/generate.js";
+import { resolveConfig } from "../daemon/config.js";
+import { generateIntrospectionSource, reportGenerationError } from "../daemon/generate.js";
 import { testWordPressCredentials } from "./_test-wordpress.js";
 import path from "node:path";
 import fs from "node:fs";
@@ -26,14 +26,10 @@ function formatGeneratedFileDiff(cwd, mismatch) {
 	const file = path.relative(cwd, mismatch.file) || path.basename(mismatch.file);
 	return createTwoFilesPatch(file, file, mismatch.actual, mismatch.expected, "committed", "generated", { context: 3 });
 }
-/** Every WordPress client the project configuration says it owns, with duplicates collapsed. */
-async function wordPressClientFiles(cwd, dir) {
-	const files = /* @__PURE__ */ new Set();
-	const workspaceDir = await resolveWordPressClientDir(cwd);
-	if (workspaceDir) files.add(path.resolve(cwd, workspaceDir, "wordpress.ts"));
+/** The generated introspection the project configuration owns, if any. */
+async function introspectionFiles(cwd, dir) {
 	const config = await resolveConfig(cwd, { dir });
-	if (config) files.add(path.resolve(cwd, config.wordpressPath));
-	return [...files];
+	return config ? [path.resolve(cwd, config.introspectionPath)] : [];
 }
 const check = defineCommand({
 	meta: {
@@ -52,9 +48,9 @@ const check = defineCommand({
 	},
 	async run({ args }) {
 		const cwd = process.cwd();
-		const files = await wordPressClientFiles(cwd, args.dir);
+		const files = await introspectionFiles(cwd, args.dir);
 		if (files.length === 0) {
-			log.info("No generated WordPress client configured, nothing to check.");
+			log.info("No generated WordPress introspection configured, nothing to check.");
 			return;
 		}
 		let credentials;
@@ -67,18 +63,18 @@ const check = defineCommand({
 		}
 		let expected;
 		try {
-			expected = await generateWordPressSource(cwd, {
+			expected = await generateIntrospectionSource(cwd, {
 				credentials,
 				strict: true
 			});
 		} catch (error) {
-			reportGenerationError("Failed to check the generated WordPress client:", error);
+			reportGenerationError("Failed to check the generated WordPress introspection:", error);
 			process.exitCode = 1;
 			return;
 		}
 		const mismatches = findGeneratedFileMismatches(files, expected);
 		if (mismatches.length === 0) {
-			log.success(`${files.length === 1 ? "WordPress client is" : "WordPress clients are"} current`);
+			log.success("WordPress introspection is current");
 			return;
 		}
 		for (const mismatch of mismatches) {
@@ -90,7 +86,7 @@ const check = defineCommand({
 			args.test ? "--test" : "",
 			args.dir ? `--dir ${args.dir}` : ""
 		].filter(Boolean).join(" ");
-		log.info(`Run \`${command}\` and commit the updated client.`);
+		log.info(`Run \`${command}\` and commit the updated introspection.`);
 		process.exitCode = 1;
 	}
 });

package/dist/cli/commands/dev.js

@@ -25,12 +25,12 @@ async function resolve$1(cwd) {
 }
 /**
 * The lifecycle subcommands (`stop`/`reset`) only act on local WordPress. A project pointing at its
-* own WordPress (no `dev.local`) has nothing to manage, so print a plain note and exit cleanly. Returns
+* own WordPress (no `local`) has nothing to manage, so print a plain note and exit cleanly. Returns
 * true when local WordPress is configured and the caller may proceed.
 */
 async function requireLocalWordPress(cwd) {
 	if (await usesLocalWordPress(cwd)) return true;
-	note("This project doesn't run local WordPress — set `dev.local: true` in kizlo.config.ts to add it.");
+	note("This project doesn't run local WordPress — set `local: true` in kizlo.config.ts to add it.");
 	return false;
 }
 /** A dim, untagged one-liner (no consola timestamp) for the clean dev output. */
@@ -351,7 +351,7 @@ async function watchOnly(cwd) {
 async function bringUp() {
 	const cwd = process.cwd();
 	if (!await usesLocalWordPress(cwd)) {
-		note("This project doesn't run local WordPress — running the contract watcher only. Set `dev.local` in kizlo.config.ts to add it.");
+		note("This project doesn't run local WordPress — running the contract watcher only. Set `local` in kizlo.config.ts to add it.");
 		await watchOnly(cwd);
 		return;
 	}

package/dist/cli/commands/generate.js

@@ -1,6 +1,6 @@
 import { log } from "../daemon/logger.js";
-import { resolveConfig, resolveWordPressClientDir } from "../daemon/config.js";
-import { PartialContractError, generateOnce, generateWorkspaceClientOnce, reportGenerationError } from "../daemon/generate.js";
+import { resolveConfig } from "../daemon/config.js";
+import { PartialContractError, generateOnce, reportGenerationError } from "../daemon/generate.js";
 import { testWordPressCredentials } from "./_test-wordpress.js";
 import path from "node:path";
 import { defineCommand } from "citty";
@@ -12,7 +12,7 @@ import { defineCommand } from "citty";
 * mode did not do to the files on disk.
 */
 function fail(message, error) {
-	if (error instanceof PartialContractError) log.error(`${error.message} The generated client on disk is unchanged.`);
+	if (error instanceof PartialContractError) log.error(`${error.message} The generated introspection on disk is unchanged.`);
 	else reportGenerationError(message, error);
 	process.exit(1);
 }
@@ -28,7 +28,7 @@ const generate = defineCommand({
 		},
 		strict: {
 			type: "boolean",
-			description: "Fail instead of generating a client WordPress had to exclude routes or types from"
+			description: "Fail instead of generating an introspection WordPress had to exclude routes or types from"
 		},
 		test: {
 			type: "boolean",
@@ -50,29 +50,27 @@ const generate = defineCommand({
 			credentials,
 			strict
 		};
-		const wordpressClientDir = await resolveWordPressClientDir(cwd);
-		if (wordpressClientDir) try {
-			const result = await generateWorkspaceClientOnce(cwd, wordpressClientDir, options);
-			const file = path.resolve(cwd, wordpressClientDir, "wordpress.ts");
-			log.success(`WordPress client ${result === "generated" ? "written to" : "already current at"} ${file}`);
-		} catch (error) {
-			fail("Failed to generate the WordPress client:", error);
-		}
 		const cfg = await resolveConfig(cwd, { dir: args.dir });
 		if (!cfg) {
-			if (!wordpressClientDir) log.info("No Kizlo server directory configured, nothing to generate. Set `dir` in kizlo.config.ts or pass --dir.");
+			log.info("Nothing to generate. Set `dir` in kizlo.config.ts or pass --dir.");
 			return;
 		}
-		let ok;
+		let result;
 		try {
-			ok = await generateOnce(cfg, options);
+			result = await generateOnce(cfg, options);
 		} catch (error) {
 			fail("Failed to generate the Kizlo contract:", error);
 		}
-		if (!ok) {
-			log.error(`No Kizlo server found in ${cfg.serverEntry}`);
+		if (result.contract === "empty" && cfg.server) {
+			log.error(`No Kizlo server found in ${cfg.server.entry}`);
 			process.exit(1);
 		}
+		if (result.contract === "none") {
+			const file = path.resolve(cwd, cfg.introspectionPath);
+			log.success(`WordPress introspection ${result.introspection === "generated" ? "written to" : "already current at"} ${file}`);
+			return;
+		}
+		if (result.introspection === "generated") log.success("WordPress introspection generated");
 		log.success("Contract generated");
 	}
 });

package/dist/cli/commands/test.js

@@ -114,9 +114,9 @@ const runArgs = {
 	}
 };
 /**
-* Run the project's tests. When `test.local` is set, boot (+ seed) local WordPress first, run the
-* suite (JS then the plugin's PHPUnit) against it, then leave it up (or tear down). Without
-* `test.local`, there's no Docker WordPress to manage — just run the project's own test script.
+* Run the project's tests. When the test stack is enabled (`local` with `test.enable !== false`), boot
+* (+ seed) local WordPress first, run the suite (JS then the plugin's PHPUnit) against it, then leave it
+* up (or tear down). Otherwise there's no Docker WordPress to manage — just run the project's own test script.
 */
 async function runSuite({ args }) {
 	const cfg = await resolveTestConfig(process.cwd());