@donkeylabs/cli 2.0.14 → 2.0.16

package/templates/sveltekit-app/src/server/plugins/workflow-demo/index.ts

@@ -1,198 +0,0 @@
-// Workflow Demo Plugin - Demonstrates step function orchestration
-import { createPlugin, workflow, type WorkflowContext, type CoreServices } from "@donkeylabs/server";
-import { z } from "zod";
-
-// Helper to simulate async work with delay
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-// Input/output types for better type safety
-type OrderInput = {
-  orderId: string;
-  items: { name: string; qty: number }[];
-  customerEmail: string;
-};
-
-type ValidateOutput = { valid: boolean; total: number; itemCount: number };
-type PaymentOutput = { paymentId: string; status: string };
-
-// Define an example order processing workflow with placeholder tasks
-export const orderWorkflow = workflow("process-order")
-  .timeout(60000) // 1 minute max
-  .defaultRetry({ maxAttempts: 2 })
-
-  // Step 1: Validate Order
-  .task("validate", {
-    inputSchema: z.object({
-      orderId: z.string(),
-      items: z.array(z.object({ name: z.string(), qty: z.number() })),
-      customerEmail: z.string().email(),
-    }),
-    outputSchema: z.object({
-      valid: z.boolean(),
-      total: z.number(),
-      itemCount: z.number(),
-    }),
-    handler: async (input: OrderInput, ctx: { core: CoreServices }): Promise<ValidateOutput> => {
-      ctx.core.logger.info("Validating order", { orderId: input.orderId });
-      await sleep(1000); // Simulate validation work
-      const total = input.items.reduce((sum: number, item: { qty: number }) => sum + item.qty * 10, 0);
-      return { valid: true, total, itemCount: input.items.length };
-    },
-  })
-
-  // Step 2: Process Payment
-  .task("payment", {
-    inputSchema: (prev: ValidateOutput, workflowInput: OrderInput) => ({
-      orderId: workflowInput.orderId,
-      amount: prev.total,
-      email: workflowInput.customerEmail,
-    }),
-    outputSchema: z.object({
-      paymentId: z.string(),
-      status: z.string(),
-    }),
-    handler: async (input: { orderId: string; amount: number; email: string }, ctx: { core: CoreServices }): Promise<PaymentOutput> => {
-      ctx.core.logger.info("Processing payment", {
-        orderId: input.orderId,
-        amount: input.amount,
-      });
-      await sleep(2000); // Simulate payment processing
-      return {
-        paymentId: `PAY-${Date.now().toString(36).toUpperCase()}`,
-        status: "completed",
-      };
-    },
-  })
-
-  // Step 3: Parallel - Send Notification + Prepare Shipment
-  .parallel("fulfill", {
-    branches: [
-      workflow
-        .branch("notification")
-        .task("send-email", {
-          handler: async (_input: unknown, ctx: { core: CoreServices }) => {
-            ctx.core.logger.info("Sending confirmation email");
-            await sleep(800); // Simulate email send
-            return { emailSent: true, sentAt: new Date().toISOString() };
-          },
-        })
-        .build(),
-
-      workflow
-        .branch("shipping")
-        .task("prepare-shipment", {
-          handler: async (_input: unknown, ctx: { core: CoreServices }) => {
-            ctx.core.logger.info("Preparing shipment");
-            await sleep(1500); // Simulate shipment prep
-            return {
-              trackingId: `SHIP-${Date.now().toString(36).toUpperCase()}`,
-              carrier: "FastShip",
-              estimatedDelivery: new Date(
-                Date.now() + 3 * 24 * 60 * 60 * 1000
-              ).toISOString(),
-            };
-          },
-        })
-        .build(),
-    ],
-    next: "complete",
-  })
-
-  // Step 4: Complete
-  .pass("complete", {
-    transform: (ctx: WorkflowContext) => ({
-      orderId: ctx.input.orderId,
-      paymentId: ctx.steps["payment"].paymentId,
-      // Parallel branch outputs are stored directly by branch name
-      tracking: ctx.steps["fulfill"].shipping.trackingId,
-      emailSent: ctx.steps["fulfill"].notification.emailSent,
-      completedAt: new Date().toISOString(),
-    }),
-    end: true,
-  })
-  .build();
-
-// Plugin that registers the workflow and provides service methods
-export const workflowDemoPlugin = createPlugin.define({
-  name: "workflowDemo",
-  service: async (ctx) => ({
-    // Start a new order processing workflow
-    startOrder: async (input: {
-      orderId: string;
-      items: { name: string; qty: number }[];
-      customerEmail: string;
-    }) => {
-      const instanceId = await ctx.core.workflows.start("process-order", input);
-      return { instanceId };
-    },
-
-    // Get workflow instance status
-    getStatus: async (instanceId: string) => {
-      const instance = await ctx.core.workflows.getInstance(instanceId);
-      if (!instance) return null;
-
-      return {
-        id: instance.id,
-        status: instance.status,
-        currentStep: instance.currentStep,
-        input: instance.input,
-        output: instance.output,
-        error: instance.error,
-        stepResults: instance.stepResults,
-        createdAt: instance.createdAt.toISOString(),
-        startedAt: instance.startedAt?.toISOString(),
-        completedAt: instance.completedAt?.toISOString(),
-      };
-    },
-
-    // List all workflow instances
-    listInstances: async (status?: string) => {
-      const instances = await ctx.core.workflows.getInstances(
-        "process-order",
-        status as any
-      );
-      return instances.map((i) => ({
-        id: i.id,
-        status: i.status,
-        currentStep: i.currentStep,
-        createdAt: i.createdAt.toISOString(),
-        completedAt: i.completedAt?.toISOString(),
-      }));
-    },
-
-    // Cancel a running workflow
-    cancel: async (instanceId: string) => {
-      const success = await ctx.core.workflows.cancel(instanceId);
-      return { success };
-    },
-  }),
-
-  init: async (ctx) => {
-    // Register the workflow definition
-    ctx.core.workflows.register(orderWorkflow);
-
-    // Broadcast workflow events to SSE for real-time UI updates
-    const workflowEvents = [
-      "workflow.started",
-      "workflow.progress",
-      "workflow.completed",
-      "workflow.failed",
-      "workflow.cancelled",
-      "workflow.step.started",
-      "workflow.step.completed",
-      "workflow.step.failed",
-    ];
-
-    for (const event of workflowEvents) {
-      ctx.core.events.on(event, (data: any) => {
-        // Broadcast to workflow-specific channel
-        ctx.core.sse.broadcast(`workflow:${data.instanceId}`, event, data);
-
-        // Also broadcast to general workflow-updates channel for the demo list
-        ctx.core.sse.broadcast("workflow-updates", event, data);
-      });
-    }
-
-    ctx.core.logger.info("Workflow demo plugin initialized with order workflow");
-  },
-});

package/templates/sveltekit-app/src/server/routes/auth/auth.schemas.ts

@@ -1,66 +0,0 @@
-import { z } from "zod";
-
-// =============================================================================
-// INPUT SCHEMAS
-// =============================================================================
-
-export const registerSchema = z.object({
-  email: z.string().email("Invalid email address"),
-  password: z.string().min(8, "Password must be at least 8 characters"),
-  name: z.string().min(1).optional(),
-});
-
-export const loginSchema = z.object({
-  email: z.string().email("Invalid email address"),
-  password: z.string().min(1, "Password is required"),
-});
-
-export const refreshSchema = z.object({
-  refreshToken: z.string(),
-});
-
-export const updateProfileSchema = z.object({
-  name: z.string().min(1).optional(),
-  email: z.string().email().optional(),
-});
-
-// =============================================================================
-// OUTPUT SCHEMAS
-// =============================================================================
-
-export const userSchema = z.object({
-  id: z.string(),
-  email: z.string(),
-  name: z.string().nullable(),
-});
-
-export const tokensSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string().optional(),
-  expiresIn: z.number(),
-});
-
-export const authResponseSchema = z.object({
-  user: userSchema,
-  tokens: tokensSchema,
-});
-
-export const refreshResponseSchema = tokensSchema;
-
-export const meResponseSchema = userSchema.nullable();
-
-export const logoutResponseSchema = z.object({
-  success: z.boolean(),
-});
-
-// =============================================================================
-// DERIVED TYPES
-// =============================================================================
-
-export type RegisterInput = z.infer<typeof registerSchema>;
-export type LoginInput = z.infer<typeof loginSchema>;
-export type RefreshInput = z.infer<typeof refreshSchema>;
-export type UpdateProfileInput = z.infer<typeof updateProfileSchema>;
-export type User = z.infer<typeof userSchema>;
-export type Tokens = z.infer<typeof tokensSchema>;
-export type AuthResponse = z.infer<typeof authResponseSchema>;

package/templates/sveltekit-app/src/server/routes/auth/handlers/login.handler.ts

@@ -1,18 +0,0 @@
-/**
- * Login Handler - Authenticate user and create session/token
- */
-export class LoginHandler {
-  constructor(private ctx: any) {}
-
-  async handle(input: { email: string; password: string }) {
-    const result = await (this.ctx.plugins as any).auth.login({
-      email: input.email,
-      password: input.password,
-    });
-
-    return {
-      user: result.user,
-      tokens: result.tokens,
-    };
-  }
-}

package/templates/sveltekit-app/src/server/routes/auth/handlers/logout.handler.ts

@@ -1,16 +0,0 @@
-/**
- * Logout Handler - Invalidate current session/token
- */
-export class LogoutHandler {
-  constructor(private ctx: any) {}
-
-  async handle(_input: Record<string, never>) {
-    const token = this.ctx.token;
-
-    if (token) {
-      await (this.ctx.plugins as any).auth.logout(token);
-    }
-
-    return { success: true };
-  }
-}

package/templates/sveltekit-app/src/server/routes/auth/handlers/me.handler.ts

@@ -1,20 +0,0 @@
-/**
- * Me Handler - Get current authenticated user
- */
-export class MeHandler {
-  constructor(private ctx: any) {}
-
-  async handle(_input: Record<string, never>) {
-    const user = this.ctx.user;
-
-    if (!user) {
-      return null;
-    }
-
-    return {
-      id: user.id,
-      email: user.email,
-      name: user.name,
-    };
-  }
-}

package/templates/sveltekit-app/src/server/routes/auth/handlers/refresh.handler.ts

@@ -1,17 +0,0 @@
-/**
- * Refresh Handler - Get new access token using refresh token
- * Only available with refresh-token strategy
- */
-export class RefreshHandler {
-  constructor(private ctx: any) {}
-
-  async handle(input: { refreshToken: string }) {
-    const tokens = await (this.ctx.plugins as any).auth.refresh(input.refreshToken);
-
-    return {
-      accessToken: tokens.accessToken,
-      refreshToken: tokens.refreshToken,
-      expiresIn: tokens.expiresIn,
-    };
-  }
-}

package/templates/sveltekit-app/src/server/routes/auth/handlers/register.handler.ts

@@ -1,19 +0,0 @@
-/**
- * Register Handler - Create a new user account
- */
-export class RegisterHandler {
-  constructor(private ctx: any) {}
-
-  async handle(input: { email: string; password: string; name: string }) {
-    const result = await (this.ctx.plugins as any).auth.register({
-      email: input.email,
-      password: input.password,
-      name: input.name,
-    });
-
-    return {
-      user: result.user,
-      tokens: result.tokens,
-    };
-  }
-}

package/templates/sveltekit-app/src/server/routes/auth/handlers/update-profile.handler.ts

@@ -1,21 +0,0 @@
-/**
- * Update Profile Handler - Update current user's profile
- */
-export class UpdateProfileHandler {
-  constructor(private ctx: any) {}
-
-  async handle(input: { name?: string; email?: string }) {
-    const user = this.ctx.user;
-
-    if (!user) {
-      throw this.ctx.errors.Unauthorized("Not authenticated");
-    }
-
-    const updated = await (this.ctx.plugins as any).auth.updateProfile(user.id, {
-      name: input.name,
-      email: input.email,
-    });
-
-    return updated;
-  }
-}

package/templates/sveltekit-app/src/server/routes/auth/index.ts

@@ -1,73 +0,0 @@
-/**
- * Auth Router - Authentication endpoints
- *
- * Provides:
- * - auth.register - Create new account
- * - auth.login - Login and get tokens
- * - auth.refresh - Refresh access token (refresh-token strategy only)
- * - auth.logout - Invalidate session/token
- * - auth.me - Get current user
- * - auth.updateProfile - Update profile
- */
-
-import { createRouter } from "@donkeylabs/server";
-import { z } from "zod";
-import {
-  registerSchema,
-  loginSchema,
-  refreshSchema,
-  updateProfileSchema,
-  authResponseSchema,
-  refreshResponseSchema,
-  userSchema,
-  logoutResponseSchema,
-} from "./auth.schemas";
-import { RegisterHandler } from "./handlers/register.handler";
-import { LoginHandler } from "./handlers/login.handler";
-import { RefreshHandler } from "./handlers/refresh.handler";
-import { LogoutHandler } from "./handlers/logout.handler";
-import { MeHandler } from "./handlers/me.handler";
-import { UpdateProfileHandler } from "./handlers/update-profile.handler";
-
-export const authRouter = createRouter("auth")
-
-  // Public routes
-  .route("register").typed({
-    input: registerSchema,
-    output: authResponseSchema,
-    handle: RegisterHandler,
-  })
-
-  .route("login").typed({
-    input: loginSchema,
-    output: authResponseSchema,
-    handle: LoginHandler,
-  })
-
-  // Refresh token (for refresh-token strategy)
-  .route("refresh").typed({
-    input: refreshSchema,
-    output: refreshResponseSchema,
-    handle: RefreshHandler,
-  })
-
-  // Get current user (returns null if not authenticated)
-  .route("me").typed({
-    input: z.object({}),
-    output: userSchema.nullable(),
-    handle: MeHandler,
-  })
-
-  // Logout (invalidate session/token)
-  .route("logout").typed({
-    input: z.object({}),
-    output: logoutResponseSchema,
-    handle: LogoutHandler,
-  })
-
-  // Update profile
-  .route("updateProfile").typed({
-    input: updateProfileSchema,
-    output: userSchema,
-    handle: UpdateProfileHandler,
-  });