@donkeylabs/server 0.3.0 → 0.4.0

package/src/core/cache.ts

@@ -24,17 +24,6 @@ export interface Cache {
   clear(): Promise<void>;
   keys(pattern?: string): Promise<string[]>;
   getOrSet<T>(key: string, factory: () => Promise<T>, ttlMs?: number): Promise<T>;
-
-  /** Create a namespaced cache with automatic key prefixing */
-  namespace(prefix: string): NamespacedCache;
-}
-
-/** A cache namespace with automatic key prefixing and optional TTL policy */
-export interface NamespacedCache extends Omit<Cache, "namespace"> {
-  /** The namespace prefix */
-  readonly prefix: string;
-  /** Clear only keys in this namespace */
-  clearNamespace(): Promise<void>;
 }
 
 interface CacheEntry<T> {
@@ -187,70 +176,6 @@ class CacheImpl implements Cache {
     await this.set(key, value, ttlMs);
     return value;
   }
-
-  namespace(prefix: string): NamespacedCache {
-    return new NamespacedCacheImpl(this, prefix);
-  }
-}
-
-/** Namespaced cache that automatically prefixes all keys */
-class NamespacedCacheImpl implements NamespacedCache {
-  readonly prefix: string;
-  private parent: Cache;
-
-  constructor(parent: Cache, prefix: string) {
-    this.parent = parent;
-    this.prefix = prefix.endsWith(":") ? prefix : `${prefix}:`;
-  }
-
-  private prefixKey(key: string): string {
-    return `${this.prefix}${key}`;
-  }
-
-  async get<T>(key: string): Promise<T | null> {
-    return this.parent.get<T>(this.prefixKey(key));
-  }
-
-  async set<T>(key: string, value: T, ttlMs?: number): Promise<void> {
-    return this.parent.set(this.prefixKey(key), value, ttlMs);
-  }
-
-  async delete(key: string): Promise<boolean> {
-    return this.parent.delete(this.prefixKey(key));
-  }
-
-  async has(key: string): Promise<boolean> {
-    return this.parent.has(this.prefixKey(key));
-  }
-
-  async clear(): Promise<void> {
-    // Clear the entire cache (same as parent)
-    return this.parent.clear();
-  }
-
-  async clearNamespace(): Promise<void> {
-    // Clear only keys with this namespace prefix
-    const keys = await this.parent.keys(`${this.prefix}*`);
-    for (const key of keys) {
-      await this.parent.delete(key);
-    }
-  }
-
-  async keys(pattern?: string): Promise<string[]> {
-    // Get keys with namespace prefix, then strip the prefix from results
-    const fullPattern = pattern ? `${this.prefix}${pattern}` : `${this.prefix}*`;
-    const keys = await this.parent.keys(fullPattern);
-    return keys.map(k => k.slice(this.prefix.length));
-  }
-
-  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlMs?: number): Promise<T> {
-    const existing = await this.get<T>(key);
-    if (existing !== null) return existing;
-
-    const value = await factory();
-    await this.set(key, value, ttlMs);
-    return value;
-  }
 }
 
 export function createCache(config?: CacheConfig): Cache {

package/src/core/cron.ts

@@ -9,22 +9,6 @@ export interface CronTask {
   enabled: boolean;
   lastRun?: Date;
   nextRun?: Date;
-  /** Plugin that registered this task */
-  pluginName?: string;
-  /** Optional description */
-  description?: string;
-}
-
-/** Declarative cron task definition for plugin registration */
-export interface CronTaskDefinition {
-  /** Cron expression (5 or 6 fields) */
-  expression: string;
-  /** Task handler function */
-  handler: () => void | Promise<void>;
-  /** Whether task starts enabled (default: true) */
-  enabled?: boolean;
-  /** Optional description */
-  description?: string;
 }
 
 export interface CronConfig {
@@ -32,39 +16,16 @@ export interface CronConfig {
 }
 
 export interface Cron {
-  /** Schedule a cron task (imperative API) */
   schedule(
     expression: string,
     handler: () => void | Promise<void>,
-    options?: { name?: string; enabled?: boolean; pluginName?: string; description?: string }
+    options?: { name?: string; enabled?: boolean }
   ): string;
-
-  /** Register a named cron task (declarative API) */
-  registerTask(
-    name: string,
-    definition: CronTaskDefinition,
-    pluginName?: string
-  ): string;
-
-  /** Register multiple cron tasks (for plugins) */
-  registerTasks(
-    tasks: Record<string, CronTaskDefinition>,
-    pluginName?: string
-  ): string[];
-
   unschedule(taskId: string): boolean;
   pause(taskId: string): void;
   resume(taskId: string): void;
   list(): CronTask[];
-
-  /** List tasks registered by a specific plugin */
-  listByPlugin(pluginName: string): CronTask[];
-
   get(taskId: string): CronTask | undefined;
-
-  /** Get task by name */
-  getByName(name: string): CronTask | undefined;
-
   trigger(taskId: string): Promise<void>;
   start(): void;
   stop(): Promise<void>;
@@ -170,12 +131,8 @@ interface InternalCronTask extends CronTask {
   _cronExpr: CronExpression;
 }
 
-/** Index tasks by name for quick lookup */
-type TaskNameIndex = Map<string, string>; // name -> id
-
 class CronImpl implements Cron {
   private tasks = new Map<string, InternalCronTask>();
-  private taskNameIndex: TaskNameIndex = new Map();
   private running = false;
   private timer: ReturnType<typeof setInterval> | null = null;
   private taskCounter = 0;
@@ -187,63 +144,27 @@ class CronImpl implements Cron {
   schedule(
     expression: string,
     handler: () => void | Promise<void>,
-    options: { name?: string; enabled?: boolean; pluginName?: string; description?: string } = {}
+    options: { name?: string; enabled?: boolean } = {}
   ): string {
     const id = `cron_${++this.taskCounter}_${Date.now()}`;
     const cronExpr = new CronExpression(expression);
-    const name = options.name ?? id;
 
     const task: InternalCronTask = {
       id,
-      name,
+      name: options.name ?? id,
       expression,
       handler,
       enabled: options.enabled ?? true,
       nextRun: cronExpr.getNextRun(),
-      pluginName: options.pluginName,
-      description: options.description,
       _cronExpr: cronExpr,
     };
 
     this.tasks.set(id, task);
-    this.taskNameIndex.set(name, id);
 
     return id;
   }
 
-  registerTask(
-    name: string,
-    definition: CronTaskDefinition,
-    pluginName?: string
-  ): string {
-    if (this.taskNameIndex.has(name)) {
-      throw new Error(`Cron task "${name}" is already registered`);
-    }
-
-    return this.schedule(definition.expression, definition.handler, {
-      name,
-      enabled: definition.enabled,
-      pluginName,
-      description: definition.description,
-    });
-  }
-
-  registerTasks(
-    tasks: Record<string, CronTaskDefinition>,
-    pluginName?: string
-  ): string[] {
-    const ids: string[] = [];
-    for (const [name, definition] of Object.entries(tasks)) {
-      ids.push(this.registerTask(name, definition, pluginName));
-    }
-    return ids;
-  }
-
   unschedule(taskId: string): boolean {
-    const task = this.tasks.get(taskId);
-    if (task) {
-      this.taskNameIndex.delete(task.name);
-    }
     return this.tasks.delete(taskId);
   }
 
@@ -270,15 +191,9 @@ class CronImpl implements Cron {
       enabled: t.enabled,
       lastRun: t.lastRun,
       nextRun: t.nextRun,
-      pluginName: t.pluginName,
-      description: t.description,
     }));
   }
 
-  listByPlugin(pluginName: string): CronTask[] {
-    return this.list().filter(task => task.pluginName === pluginName);
-  }
-
   get(taskId: string): CronTask | undefined {
     const task = this.tasks.get(taskId);
     if (!task) return undefined;
@@ -290,17 +205,9 @@ class CronImpl implements Cron {
       enabled: task.enabled,
       lastRun: task.lastRun,
       nextRun: task.nextRun,
-      pluginName: task.pluginName,
-      description: task.description,
     };
   }
 
-  getByName(name: string): CronTask | undefined {
-    const id = this.taskNameIndex.get(name);
-    if (!id) return undefined;
-    return this.get(id);
-  }
-
   async trigger(taskId: string): Promise<void> {
     const task = this.tasks.get(taskId);
     if (!task) throw new Error(`Task ${taskId} not found`);

package/src/core/errors.ts

@@ -3,9 +3,21 @@
  *
  * Provides throwable HTTP errors that are automatically caught by the server
  * and converted to proper HTTP responses with status codes and error bodies.
+ *
+ * Usage:
+ *   throw ctx.errors.BadRequest("Invalid user ID");
+ *   throw ctx.errors.NotFound("User not found", { userId: 123 });
+ *   throw ctx.errors.Unauthorized("Please log in");
  */
 
-/** Base class for all HTTP errors */
+// ==========================================
+// Base HTTP Error
+// ==========================================
+
+/**
+ * Base class for all HTTP errors.
+ * Thrown errors are caught by the server and converted to HTTP responses.
+ */
 export class HttpError extends Error {
   /** HTTP status code */
   readonly status: number;
@@ -56,6 +68,10 @@ export class HttpError extends Error {
   }
 }
 
+// ==========================================
+// Standard HTTP Error Classes
+// ==========================================
+
 /** 400 Bad Request */
 export class BadRequestError extends HttpError {
   constructor(message: string = "Bad Request", details?: Record<string, any>, cause?: Error) {
@@ -168,35 +184,65 @@ export class GatewayTimeoutError extends HttpError {
   }
 }
 
-/** Factory function signature for creating errors */
+// ==========================================
+// Error Factory Type
+// ==========================================
+
+/**
+ * Factory function signature for creating errors
+ */
 export type ErrorFactory<T extends HttpError = HttpError> = (
   message?: string,
   details?: Record<string, any>,
   cause?: Error
 ) => T;
 
-/** Base error factories available on ctx.errors */
+/**
+ * Base error factories available on ctx.errors
+ */
 export interface BaseErrorFactories {
+  /** 400 Bad Request */
   BadRequest: ErrorFactory<BadRequestError>;
+  /** 401 Unauthorized */
   Unauthorized: ErrorFactory<UnauthorizedError>;
+  /** 403 Forbidden */
   Forbidden: ErrorFactory<ForbiddenError>;
+  /** 404 Not Found */
   NotFound: ErrorFactory<NotFoundError>;
+  /** 405 Method Not Allowed */
   MethodNotAllowed: ErrorFactory<MethodNotAllowedError>;
+  /** 409 Conflict */
   Conflict: ErrorFactory<ConflictError>;
+  /** 410 Gone */
   Gone: ErrorFactory<GoneError>;
+  /** 422 Unprocessable Entity */
   UnprocessableEntity: ErrorFactory<UnprocessableEntityError>;
+  /** 429 Too Many Requests */
   TooManyRequests: ErrorFactory<TooManyRequestsError>;
+  /** 500 Internal Server Error */
   InternalServer: ErrorFactory<InternalServerError>;
+  /** 501 Not Implemented */
   NotImplemented: ErrorFactory<NotImplementedError>;
+  /** 502 Bad Gateway */
   BadGateway: ErrorFactory<BadGatewayError>;
+  /** 503 Service Unavailable */
   ServiceUnavailable: ErrorFactory<ServiceUnavailableError>;
+  /** 504 Gateway Timeout */
   GatewayTimeout: ErrorFactory<GatewayTimeoutError>;
 }
 
-/** Extended error factories (augmented by plugins and user) */
+/**
+ * Extended error factories (augmented by plugins and user)
+ */
 export interface ErrorFactories extends BaseErrorFactories {}
 
-/** Definition for a custom error type */
+// ==========================================
+// Custom Error Definition
+// ==========================================
+
+/**
+ * Definition for a custom error type
+ */
 export interface CustomErrorDefinition {
   /** HTTP status code */
   status: number;
@@ -206,9 +252,15 @@ export interface CustomErrorDefinition {
   defaultMessage?: string;
 }
 
-/** Registry of custom error definitions */
+/**
+ * Registry of custom error definitions
+ */
 export type CustomErrorRegistry = Record<string, CustomErrorDefinition>;
 
+// ==========================================
+// Error Service
+// ==========================================
+
 export interface ErrorsConfig {
   /** Include stack traces in error responses (default: false in production) */
   includeStackTrace?: boolean;
@@ -217,7 +269,9 @@ export interface ErrorsConfig {
 }
 
 export interface Errors extends ErrorFactories {
-  /** Create a custom HTTP error */
+  /**
+   * Create a custom HTTP error
+   */
   custom(
     status: number,
     code: string,
@@ -226,17 +280,23 @@ export interface Errors extends ErrorFactories {
     cause?: Error
   ): HttpError;
 
-  /** Check if an error is an HttpError */
+  /**
+   * Check if an error is an HttpError
+   */
   isHttpError(error: unknown): error is HttpError;
 
-  /** Register a custom error type */
+  /**
+   * Register a custom error type
+   */
   register<K extends string>(
     name: K,
     definition: CustomErrorDefinition
   ): void;
 }
 
-/** Create the errors service */
+/**
+ * Create the errors service
+ */
 export function createErrors(config: ErrorsConfig = {}): Errors {
   const customErrors = new Map<string, CustomErrorDefinition>(
     Object.entries(config.customErrors || {})
@@ -307,7 +367,14 @@ export function createErrors(config: ErrorsConfig = {}): Errors {
   return errors;
 }
 
-/** Create a BadRequestError with validation details (useful for Zod validation errors) */
+// ==========================================
+// Validation Error Helper
+// ==========================================
+
+/**
+ * Create a BadRequestError with validation details
+ * Useful for Zod validation errors
+ */
 export function createValidationError(
   issues: Array<{ path: (string | number)[]; message: string }>
 ): BadRequestError {

package/src/core/events.ts

@@ -1,7 +1,5 @@
 // Core Events Service
-// Pub/sub async event queue with schema validation
-
-import { z } from "zod";
+// Pub/sub async event queue
 
 export interface EventHandler<T = any> {
   (data: T): void | Promise<void>;
@@ -28,15 +26,6 @@ export interface EventsConfig {
 }
 
 export interface Events {
-  // Schema registration (strict - events must be registered before emit)
-  register<T>(event: string, schema: z.ZodType<T>): void;
-  registerMany(schemas: Record<string, z.ZodType<any>>): void;
-  isRegistered(event: string): boolean;
-  getSchema(event: string): z.ZodType<any> | undefined;
-  /** List all registered event names */
-  listRegistered(): string[];
-
-  // Event operations
   emit<T = any>(event: string, data: T): Promise<void>;
   on<T = any>(event: string, handler: EventHandler<T>): Subscription;
   once<T = any>(event: string, handler: EventHandler<T>): Subscription;
@@ -78,47 +67,12 @@ export class MemoryEventAdapter implements EventAdapter {
 class EventsImpl implements Events {
   private handlers = new Map<string, Set<EventHandler>>();
   private adapter: EventAdapter;
-  private schemas = new Map<string, z.ZodType<any>>();
 
   constructor(config: EventsConfig = {}) {
     this.adapter = config.adapter ?? new MemoryEventAdapter(config.maxHistorySize);
   }
 
-  register<T>(event: string, schema: z.ZodType<T>): void {
-    this.schemas.set(event, schema);
-  }
-
-  registerMany(schemas: Record<string, z.ZodType<any>>): void {
-    for (const [name, schema] of Object.entries(schemas)) {
-      this.schemas.set(name, schema);
-    }
-  }
-
-  isRegistered(event: string): boolean {
-    return this.schemas.has(event);
-  }
-
-  getSchema(event: string): z.ZodType<any> | undefined {
-    return this.schemas.get(event);
-  }
-
-  listRegistered(): string[] {
-    return Array.from(this.schemas.keys());
-  }
-
   async emit<T = any>(event: string, data: T): Promise<void> {
-    // Strict mode: event must be registered
-    const schema = this.schemas.get(event);
-    if (!schema) {
-      throw new Error(`Event '${event}' is not registered. Register it first with events.register() or in plugin events config.`);
-    }
-
-    // Validate data against schema
-    const result = schema.safeParse(data);
-    if (!result.success) {
-      throw new Error(`Event '${event}' validation failed: ${result.error.message}`);
-    }
-
     // Store in adapter (for history/persistence)
     await this.adapter.publish(event, data);
 

package/src/core/index.ts

@@ -12,7 +12,6 @@ export {
 
 export {
   type Cache,
-  type NamespacedCache,
   type CacheAdapter,
   type CacheConfig,
   MemoryCacheAdapter,
@@ -33,7 +32,6 @@ export {
 export {
   type Cron,
   type CronTask,
-  type CronTaskDefinition,
   type CronConfig,
   createCron,
 } from "./cron";
@@ -43,8 +41,6 @@ export {
   type Job,
   type JobStatus,
   type JobHandler,
-  type JobDefinition,
-  type RegisteredJob,
   type JobAdapter,
   type JobsConfig,
   MemoryJobAdapter,

package/src/core/jobs.ts

@@ -2,7 +2,6 @@
 // Background job queue with scheduling
 
 import type { Events } from "./events";
-import type { z } from "zod";
 
 export type JobStatus = "pending" | "running" | "completed" | "failed" | "scheduled";
 
@@ -43,53 +42,8 @@ export interface JobsConfig {
   maxAttempts?: number; // Default retry attempts, default 3
 }
 
-export interface JobDefinition<T = any, R = any> {
-  /** Zod schema for validating job payloads */
-  schema: z.ZodType<T>;
-  /** Job handler function */
-  handler: JobHandler<T, R>;
-  /** Optional description */
-  description?: string;
-}
-
-export interface RegisteredJob {
-  name: string;
-  schema: z.ZodType<any>;
-  handler: JobHandler;
-  description?: string;
-  /** Plugin that registered this job */
-  pluginName?: string;
-}
-
 export interface Jobs {
-  /** Register a job with handler only (backward compatible, but no payload validation) */
   register<T = any, R = any>(name: string, handler: JobHandler<T, R>): void;
-
-  /** Register a job with schema validation and handler */
-  registerJob<T = any, R = any>(
-    name: string,
-    definition: JobDefinition<T, R>,
-    pluginName?: string
-  ): void;
-
-  /** Register multiple jobs at once (for plugins) */
-  registerJobs(
-    jobs: Record<string, JobDefinition>,
-    pluginName?: string
-  ): void;
-
-  /** Check if a job is registered */
-  isRegistered(name: string): boolean;
-
-  /** Get registered job info */
-  getRegisteredJob(name: string): RegisteredJob | undefined;
-
-  /** List all registered jobs */
-  listRegisteredJobs(): RegisteredJob[];
-
-  /** List registered jobs by plugin */
-  listJobsByPlugin(pluginName: string): RegisteredJob[];
-
   enqueue<T = any>(name: string, data: T, options?: { maxAttempts?: number }): Promise<string>;
   schedule<T = any>(name: string, data: T, runAt: Date, options?: { maxAttempts?: number }): Promise<string>;
   get(jobId: string): Promise<Job | null>;
@@ -162,7 +116,6 @@ class JobsImpl implements Jobs {
   private adapter: JobAdapter;
   private events?: Events;
   private handlers = new Map<string, JobHandler>();
-  private registeredJobs = new Map<string, RegisteredJob>();
   private running = false;
   private timer: ReturnType<typeof setInterval> | null = null;
   private activeJobs = 0;
@@ -185,67 +138,11 @@ class JobsImpl implements Jobs {
     this.handlers.set(name, handler);
   }
 
-  registerJob<T = any, R = any>(
-    name: string,
-    definition: JobDefinition<T, R>,
-    pluginName?: string
-  ): void {
-    if (this.registeredJobs.has(name)) {
-      throw new Error(`Job "${name}" is already registered`);
-    }
-
-    this.registeredJobs.set(name, {
-      name,
-      schema: definition.schema,
-      handler: definition.handler,
-      description: definition.description,
-      pluginName,
-    });
-
-    // Also register the handler in the handlers map for backward compatibility
-    this.handlers.set(name, definition.handler);
-  }
-
-  registerJobs(
-    jobs: Record<string, JobDefinition>,
-    pluginName?: string
-  ): void {
-    for (const [name, definition] of Object.entries(jobs)) {
-      this.registerJob(name, definition, pluginName);
-    }
-  }
-
-  isRegistered(name: string): boolean {
-    return this.registeredJobs.has(name) || this.handlers.has(name);
-  }
-
-  getRegisteredJob(name: string): RegisteredJob | undefined {
-    return this.registeredJobs.get(name);
-  }
-
-  listRegisteredJobs(): RegisteredJob[] {
-    return Array.from(this.registeredJobs.values());
-  }
-
-  listJobsByPlugin(pluginName: string): RegisteredJob[] {
-    return Array.from(this.registeredJobs.values())
-      .filter(job => job.pluginName === pluginName);
-  }
-
   async enqueue<T = any>(name: string, data: T, options: { maxAttempts?: number } = {}): Promise<string> {
     if (!this.handlers.has(name)) {
       throw new Error(`No handler registered for job "${name}"`);
     }
 
-    // Validate payload if schema is registered
-    const registered = this.registeredJobs.get(name);
-    if (registered) {
-      const result = registered.schema.safeParse(data);
-      if (!result.success) {
-        throw new Error(`Job "${name}" payload validation failed: ${result.error.message}`);
-      }
-    }
-
     const job = await this.adapter.create({
       name,
       data,
@@ -268,15 +165,6 @@ class JobsImpl implements Jobs {
       throw new Error(`No handler registered for job "${name}"`);
     }
 
-    // Validate payload if schema is registered
-    const registered = this.registeredJobs.get(name);
-    if (registered) {
-      const result = registered.schema.safeParse(data);
-      if (!result.success) {
-        throw new Error(`Job "${name}" payload validation failed: ${result.error.message}`);
-      }
-    }
-
     const job = await this.adapter.create({
       name,
       data,