keryx 0.25.1 → 0.25.3

package/initializers/actionts.ts

@@ -60,7 +60,7 @@ export type FanOutStatus = {
   errors: Array<{ params: Record<string, any>; error: string }>;
 };
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Actions["initialize"]>>;
   }

package/initializers/channels.ts

@@ -22,7 +22,7 @@ const REFRESH_PRESENCE_LUA = await Bun.file(
   join(LUA_DIR, "refresh-presence.lua"),
 ).text();
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Channels["initialize"]>>;
   }

package/initializers/connections.ts

@@ -3,7 +3,7 @@ import { Initializer } from "../classes/Initializer";
 
 const namespace = "connections";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Connections["initialize"]>>;
   }

package/initializers/db.ts

@@ -18,7 +18,7 @@ import {
 
 const namespace = "db";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<DB["initialize"]>>;
   }

package/initializers/mcp.ts

@@ -22,7 +22,7 @@ type McpHandleRequest = (req: Request, ip: string) => Promise<Response>;
 
 const namespace = "mcp";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<McpInitializer["initialize"]>>;
   }

package/initializers/oauth.ts

@@ -27,7 +27,7 @@ import {
 
 const namespace = "oauth";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<OAuthInitializer["initialize"]>>;
   }

package/initializers/observability.ts

@@ -11,7 +11,7 @@ import { config } from "../config";
 
 const namespace = "observability";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Observability["initialize"]>>;
   }

package/initializers/process.ts

@@ -4,7 +4,7 @@ import { config } from "../config";
 
 const namespace = "process";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Process["initialize"]>>;
   }

package/initializers/pubsub.ts

@@ -24,7 +24,7 @@ export type ClientUnsubscribeMessage = {
   channel: string;
 };
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<PubSub["initialize"]>>;
   }

package/initializers/redis.ts

@@ -10,7 +10,7 @@ import {
 const namespace = "redis";
 const testKey = `__keryx_test_key:${config.process.name}`;
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Redis["initialize"]>>;
   }

package/initializers/resque.ts

@@ -33,7 +33,7 @@ function logResqueEvent(
   }
 }
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Resque["initialize"]>>;
   }

package/initializers/servers.ts

@@ -8,7 +8,7 @@ import { globLoader } from "../util/glob";
 
 const namespace = "servers";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Servers["initialize"]>>;
   }

package/initializers/session.ts

@@ -87,7 +87,7 @@ async function destroy(connection: Connection) {
   return response > 0;
 }
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Session["initialize"]>>;
   }

package/initializers/signals.ts

@@ -5,7 +5,7 @@ import { config } from "../config";
 
 const namespace = "signals";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<Signals["initialize"]>>;
   }

package/initializers/swagger.ts

@@ -10,7 +10,7 @@ import {
 
 const namespace = "swagger";
 
-declare module "../classes/API" {
+declare module "keryx" {
   export interface API {
     [namespace]: Awaited<ReturnType<SwaggerInitializer["initialize"]>>;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keryx",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",

package/util/cli.ts

@@ -5,7 +5,8 @@ import { Action, api, Connection, RUN_MODE } from "../api";
 import { ExitCode } from "./../classes/ExitCode";
 import { TypedError } from "./../classes/TypedError";
 import { config } from "../config";
-import { generateComponent, getValidTypes } from "./generate";
+import { getValidTypes } from "./componentRegistry";
+import { generateComponent } from "./generate";
 import { globLoader } from "./glob";
 import {
   interactiveScaffold,

package/util/componentRegistry.ts

@@ -0,0 +1,184 @@
+import path from "path";
+import { config } from "../config";
+
+/**
+ * A component that can be produced by `keryx generate`.
+ *
+ * Built-in components (action, initializer, middleware, channel, ops, plugin)
+ * and plugin-contributed generators are both represented as `ComponentDef`s,
+ * so `generateComponent()` can handle them through a single code path.
+ */
+export interface ComponentDef {
+  /** Generator type name — what the user passes as `keryx generate <type> <name>`. */
+  type: string;
+  /** Output subdirectory relative to the project root (e.g. `"actions"`). */
+  directory: string;
+  /** Absolute path to the Mustache template for the component file. */
+  templatePath: string;
+  /** Absolute path to the Mustache template for the test file. Falls back to the default generate/test.ts.mustache. */
+  testTemplatePath?: string;
+  /** Suffix appended to the PascalCase class name (e.g. `"Middleware"` → `FooMiddleware`). */
+  classSuffix?: string;
+  /** When true, a `route` field is added to the Mustache view (used by actions). */
+  includeRoute?: boolean;
+}
+
+const generateTemplatesDir = path.join(
+  import.meta.dir,
+  "..",
+  "templates",
+  "generate",
+);
+const scaffoldTemplatesDir = path.join(
+  import.meta.dir,
+  "..",
+  "templates",
+  "scaffold",
+);
+
+const BUILT_IN_DEFS: ComponentDef[] = [
+  {
+    type: "action",
+    directory: "actions",
+    templatePath: path.join(generateTemplatesDir, "action.ts.mustache"),
+    includeRoute: true,
+  },
+  {
+    type: "initializer",
+    directory: "initializers",
+    templatePath: path.join(generateTemplatesDir, "initializer.ts.mustache"),
+  },
+  {
+    type: "middleware",
+    directory: "middleware",
+    templatePath: path.join(
+      generateTemplatesDir,
+      "action-middleware.ts.mustache",
+    ),
+    classSuffix: "Middleware",
+  },
+  {
+    type: "channel",
+    directory: "channels",
+    templatePath: path.join(generateTemplatesDir, "channel.ts.mustache"),
+    classSuffix: "Channel",
+  },
+  {
+    type: "ops",
+    directory: "ops",
+    templatePath: path.join(generateTemplatesDir, "ops.ts.mustache"),
+  },
+  {
+    type: "plugin",
+    directory: "plugins",
+    templatePath: path.join(generateTemplatesDir, "plugin.ts.mustache"),
+    classSuffix: "Plugin",
+  },
+];
+
+/**
+ * Returns all component definitions, merging built-ins with plugin-contributed generators.
+ * Plugin generators with a type matching a built-in are ignored (built-ins win).
+ */
+export function getComponentDefs(): ComponentDef[] {
+  const defs: ComponentDef[] = [...BUILT_IN_DEFS];
+  const seen = new Set(defs.map((d) => d.type));
+  for (const plugin of config.plugins) {
+    if (!plugin.generators) continue;
+    for (const gen of plugin.generators) {
+      if (seen.has(gen.type)) continue;
+      defs.push({
+        type: gen.type,
+        directory: gen.directory,
+        templatePath: gen.templatePath,
+        testTemplatePath: gen.testTemplatePath,
+      });
+      seen.add(gen.type);
+    }
+  }
+  return defs;
+}
+
+/**
+ * Look up a component definition by type. Returns undefined when unknown.
+ */
+export function getComponentDef(type: string): ComponentDef | undefined {
+  return getComponentDefs().find((d) => d.type === type);
+}
+
+/**
+ * Returns all valid generator type names (built-ins + plugin generators).
+ */
+export function getValidTypes(): string[] {
+  return getComponentDefs().map((d) => d.type);
+}
+
+/**
+ * Convert a colon-separated name to PascalCase.
+ * e.g. "user:delete" → "UserDelete", "hello" → "Hello".
+ */
+export function toClassName(name: string): string {
+  return name
+    .split(":")
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join("");
+}
+
+/**
+ * Derive a web route from a colon-separated action name.
+ * "hello" → "/hello", "user:delete" → "/user/delete".
+ */
+export function toRoute(name: string): string {
+  return "/" + name.replace(/:/g, "/");
+}
+
+/**
+ * Resolve the component output path relative to the project root.
+ * Colon-separated names nest under subdirectories:
+ * "user:delete" with directory "actions" → "actions/user/delete.ts".
+ */
+export function resolveComponentPath(def: ComponentDef, name: string): string {
+  const segments = name.split(":");
+  if (segments.length > 1) {
+    const fileName = segments.pop()!;
+    return path.join(def.directory, ...segments, `${fileName}.ts`);
+  }
+  return path.join(def.directory, `${name}.ts`);
+}
+
+/**
+ * Derive the test file path for a component path.
+ * "actions/user/delete.ts" → "__tests__/actions/user/delete.test.ts".
+ */
+export function resolveTestPath(componentPath: string): string {
+  const parsed = path.parse(componentPath);
+  return path.join("__tests__", parsed.dir, `${parsed.name}.test.ts`);
+}
+
+/**
+ * Build the Mustache view for a component, applying the definition's
+ * class-suffix and route conventions.
+ */
+export function buildComponentView(
+  def: ComponentDef,
+  name: string,
+): Record<string, string> {
+  const className = toClassName(name) + (def.classSuffix ?? "");
+  const view: Record<string, string> = { name, className };
+  if (def.includeRoute) view.route = toRoute(name);
+  return view;
+}
+
+/**
+ * Load a template from `packages/keryx/templates/generate/`.
+ */
+export async function loadGenerateTemplate(name: string): Promise<string> {
+  return Bun.file(path.join(generateTemplatesDir, name)).text();
+}
+
+/**
+ * Load a template from `packages/keryx/templates/scaffold/`.
+ */
+export async function loadScaffoldTemplate(name: string): Promise<string> {
+  return Bun.file(path.join(scaffoldTemplatesDir, name)).text();
+}

package/util/generate.ts

@@ -1,47 +1,16 @@
 import fs from "fs";
 import Mustache from "mustache";
 import path from "path";
-import type { PluginGenerator } from "../classes/Plugin";
-import { config } from "../config";
+import {
+  buildComponentView,
+  getComponentDef,
+  getValidTypes,
+  loadGenerateTemplate,
+  resolveComponentPath,
+  resolveTestPath,
+} from "./componentRegistry";
 
-const VALID_TYPES = [
-  "action",
-  "initializer",
-  "middleware",
-  "channel",
-  "ops",
-  "plugin",
-] as const;
-type GeneratorType = (typeof VALID_TYPES)[number];
-
-/**
- * Returns all valid generator types, including built-in types and
- * any custom types registered by plugins.
- */
-export function getValidTypes(): string[] {
-  const types = [...VALID_TYPES] as string[];
-  for (const plugin of config.plugins) {
-    if (plugin.generators) {
-      for (const gen of plugin.generators) {
-        if (!types.includes(gen.type)) types.push(gen.type);
-      }
-    }
-  }
-  return types;
-}
-
-/**
- * Find a plugin generator definition for a given type.
- */
-function findPluginGenerator(type: string): PluginGenerator | undefined {
-  for (const plugin of config.plugins) {
-    if (plugin.generators) {
-      const gen = plugin.generators.find((g) => g.type === type);
-      if (gen) return gen;
-    }
-  }
-  return undefined;
-}
+export { getValidTypes } from "./componentRegistry";
 
 export interface GenerateOptions {
   dryRun?: boolean;
@@ -49,89 +18,6 @@ export interface GenerateOptions {
   noTest?: boolean;
 }
 
-const templatesDir = path.join(import.meta.dir, "..", "templates", "generate");
-
-async function loadTemplate(name: string): Promise<string> {
-  return Bun.file(path.join(templatesDir, name)).text();
-}
-
-/**
- * Convert a colon-separated name to PascalCase class name.
- * e.g. "user:delete" → "UserDelete", "hello" → "Hello"
- */
-function toClassName(name: string): string {
-  return name
-    .split(":")
-    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
-    .join("");
-}
-
-/**
- * Determine the directory and filename for a component type + name.
- * Actions with colons get nested: "user:delete" → "actions/user/delete.ts"
- * Others are flat: "cache" → "initializers/cache.ts"
- */
-function resolveFilePath(type: GeneratorType, name: string): string {
-  const dirMap: Record<GeneratorType, string> = {
-    action: "actions",
-    initializer: "initializers",
-    middleware: "middleware",
-    channel: "channels",
-    ops: "ops",
-    plugin: "plugins",
-  };
-
-  const baseDir = dirMap[type];
-  const segments = name.split(":");
-
-  if (segments.length > 1) {
-    // "user:delete" → "actions/user/delete.ts"
-    const fileName = segments.pop()!;
-    return path.join(baseDir, ...segments, `${fileName}.ts`);
-  }
-
-  return path.join(baseDir, `${name}.ts`);
-}
-
-/**
- * Determine the directory and filename for a plugin generator type + name.
- */
-function resolvePluginFilePath(gen: PluginGenerator, name: string): string {
-  const segments = name.split(":");
-  if (segments.length > 1) {
-    const fileName = segments.pop()!;
-    return path.join(gen.directory, ...segments, `${fileName}.ts`);
-  }
-  return path.join(gen.directory, `${name}.ts`);
-}
-
-/**
- * Determine the test file path for a plugin generator component.
- */
-function resolvePluginTestPath(gen: PluginGenerator, name: string): string {
-  const componentPath = resolvePluginFilePath(gen, name);
-  const parsed = path.parse(componentPath);
-  return path.join("__tests__", parsed.dir, `${parsed.name}.test.ts`);
-}
-
-/**
- * Determine the test file path for a component.
- * "user:delete" action → "__tests__/actions/user/delete.test.ts"
- */
-function resolveTestPath(type: GeneratorType, name: string): string {
-  const componentPath = resolveFilePath(type, name);
-  const parsed = path.parse(componentPath);
-  return path.join("__tests__", parsed.dir, `${parsed.name}.test.ts`);
-}
-
-/**
- * Derive the web route from an action name.
- * "hello" → "/api/hello", "user:delete" → "/api/user/delete"
- */
-function toRoute(name: string): string {
-  return "/" + name.replace(/:/g, "/");
-}
-
 /**
  * Generate a component file (and optionally a test file).
  * @param type The component type to generate
@@ -146,59 +32,26 @@ export async function generateComponent(
   rootDir: string,
   options: GenerateOptions = {},
 ): Promise<string[]> {
-  const allValidTypes = getValidTypes();
-  if (!allValidTypes.includes(type)) {
+  const def = getComponentDef(type);
+  if (!def) {
     throw new Error(
-      `Unknown generator type "${type}". Valid types: ${allValidTypes.join(", ")}`,
+      `Unknown generator type "${type}". Valid types: ${getValidTypes().join(", ")}`,
     );
   }
 
-  // Check if this is a plugin-provided generator type
-  const pluginGen = VALID_TYPES.includes(type as GeneratorType)
-    ? undefined
-    : findPluginGenerator(type);
-
-  const filePath = pluginGen
-    ? resolvePluginFilePath(pluginGen, name)
-    : resolveFilePath(type as GeneratorType, name);
+  const filePath = resolveComponentPath(def, name);
   const fullPath = path.join(rootDir, filePath);
   const createdFiles: string[] = [];
 
-  // Check for conflicts
   if (!options.force && fs.existsSync(fullPath)) {
     throw new Error(
       `File already exists: ${filePath}. Use --force to overwrite.`,
     );
   }
 
-  // Build template view
-  let className = toClassName(name);
-  if (type === "middleware") className += "Middleware";
-  if (type === "channel") className += "Channel";
-  if (type === "plugin") className += "Plugin";
-
-  const view: Record<string, string> = { name, className };
-  if (type === "action") {
-    view.route = toRoute(name);
-  }
-
-  // Load and render template
-  let content: string;
-  if (pluginGen) {
-    const templateStr = await Bun.file(pluginGen.templatePath).text();
-    content = Mustache.render(templateStr, view);
-  } else {
-    const templateMap: Record<GeneratorType, string> = {
-      action: "action.ts.mustache",
-      initializer: "initializer.ts.mustache",
-      middleware: "action-middleware.ts.mustache",
-      channel: "channel.ts.mustache",
-      ops: "ops.ts.mustache",
-      plugin: "plugin.ts.mustache",
-    };
-    const template = await loadTemplate(templateMap[type as GeneratorType]);
-    content = Mustache.render(template, view);
-  }
+  const view = buildComponentView(def, name);
+  const template = await Bun.file(def.templatePath).text();
+  const content = Mustache.render(template, view);
 
   if (options.dryRun) {
     console.log(`Would create: ${filePath}`);
@@ -211,26 +64,17 @@ export async function generateComponent(
     createdFiles.push(filePath);
   }
 
-  // Generate test file
   if (!options.noTest) {
-    const testPath = pluginGen
-      ? resolvePluginTestPath(pluginGen, name)
-      : resolveTestPath(type as GeneratorType, name);
+    const testPath = resolveTestPath(filePath);
     const testFullPath = path.join(rootDir, testPath);
 
     if (!options.force && fs.existsSync(testFullPath)) {
       // Silently skip test file if it already exists
     } else {
-      let testContent: string;
-      if (pluginGen?.testTemplatePath) {
-        const testTemplateStr = await Bun.file(
-          pluginGen.testTemplatePath,
-        ).text();
-        testContent = Mustache.render(testTemplateStr, view);
-      } else {
-        const testTemplate = await loadTemplate("test.ts.mustache");
-        testContent = Mustache.render(testTemplate, view);
-      }
+      const testTemplate = def.testTemplatePath
+        ? await Bun.file(def.testTemplatePath).text()
+        : await loadGenerateTemplate("test.ts.mustache");
+      const testContent = Mustache.render(testTemplate, view);
 
       if (options.dryRun) {
         console.log(`Would create: ${testPath}`);

package/util/scaffold.ts

@@ -4,18 +4,13 @@ import Mustache from "mustache";
 import path from "path";
 import * as readline from "readline";
 import pkg from "../package.json";
+import { loadScaffoldTemplate as loadTemplate } from "./componentRegistry";
 
 export interface ScaffoldOptions {
   includeDb: boolean;
   includeExample: boolean;
 }
 
-const templatesDir = path.join(import.meta.dir, "..", "templates", "scaffold");
-
-async function loadTemplate(name: string): Promise<string> {
-  return Bun.file(path.join(templatesDir, name)).text();
-}
-
 async function prompt(question: string, defaultValue: string): Promise<string> {
   const rl = readline.createInterface({
     input: process.stdin,