@ahmadubaidillah/cli 1.1.2 → 1.1.4

package/dist/plugins/openapi/files/src/modules/openapi/openapi.routes.ts

@@ -0,0 +1,17 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { swaggerUI } from '@hono/swagger-ui';
+
+export const openApiApp = new OpenAPIHono();
+
+// Generates the OpenAPI JSON schema
+openApiApp.doc('/openapi.json', {
+  openapi: '3.0.0',
+  info: {
+    version: '1.0.0',
+    title: 'DevForge Scaffolded API',
+    description: 'Auto-generated documentation by the DevForge openapi plugin.',
+  },
+});
+
+// Swagger UI Route
+openApiApp.get('/docs', swaggerUI({ url: '/openapi.json' }));

package/dist/plugins/openapi/files/src/modules/openapi/openapi.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+// For the plugin's own registry service if we expand it
+export const pluginRegistryItemSchema = z.object({
+  name: z.string(),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/),
+  description: z.string().optional(),
+});
+
+export type PluginRegistryItem = z.infer<typeof pluginRegistryItemSchema>;

package/dist/plugins/openapi/plugin.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "openapi",
+  "description": "Auto-Generated OpenAPI / Swagger Documentation plugin.",
+  "compatibleTemplates": ["saas", "marketplace", "crm"],
+  "packageDependencies": {
+    "@hono/swagger-ui": "^0.4.0",
+    "@hono/zod-openapi": "^0.15.1"
+  },
+  "packageDevDependencies": {}
+}

package/dist/plugins/payments/files/src/modules/billing/billing.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const checkoutSchema = z.object({
+  priceId: z.string().startsWith('price_'),
+  success_url: z.string().url().optional(),
+  cancel_url: z.string().url().optional(),
+});
+
+export const webhookSchema = z.object({
+  signature: z.string().min(1),
+});
+
+export type CheckoutInput = z.infer<typeof checkoutSchema>;
+export type WebhookInput = z.infer<typeof webhookSchema>;

package/dist/plugins/payments/files/src/modules/billing/routes/billing.routes.ts

@@ -0,0 +1,57 @@
+import { Hono } from 'hono';
+import { StripeService } from '../services/stripe.service';
+import { checkoutSchema } from '../billing.schema';
+
+export const billingRoutes = new Hono<{
+  Variables: {
+    organizationId: string;
+  }
+}>();
+
+// Ensure STIPE_SECRET_KEY is defined in .env
+const stripeService = new StripeService(process.env.STRIPE_SECRET_KEY || 'sk_test_placeholder');
+
+billingRoutes.post('/webhook', async (c) => {
+  const body = await c.req.text();
+  const signature = c.req.header('stripe-signature');
+
+  if (!signature) {
+    return c.json({ error: 'Missing signature' }, 400);
+  }
+
+  // Webhook handling logic here using StripeService
+  const whSecret = process.env.STRIPE_WEBHOOK_SECRET || 'whsec_placeholder';
+  try {
+    const event = await stripeService.handleWebhook(body, signature, whSecret);
+    return c.json({ received: true });
+  } catch (err: any) {
+    return c.json({ error: `Webhook Error: ${err.message}` }, 400);
+  }
+});
+
+billingRoutes.post('/checkout', async (c) => {
+  const body = await c.req.json();
+  const result = checkoutSchema.safeParse(body);
+  if (!result.success) return c.json({ error: result.error.format() }, 400);
+
+  const { priceId } = body;
+  const organizationId = c.get('organizationId');
+  if (!organizationId) {
+    return c.json({ error: 'Unauthorized: organizationId is required' }, 401);
+  }
+  
+  // Call StripeService to create checkout session linked to the organization
+  const session = await stripeService.createCheckoutSession(organizationId, priceId);
+  return c.json({ url: session.url });
+});
+
+billingRoutes.get('/portal', async (c) => {
+  const organizationId = c.get('organizationId');
+  if (!organizationId) {
+    return c.json({ error: 'Unauthorized: organizationId is required' }, 401);
+  }
+  
+  // Call StripeService to create billing portal linked to the organization
+  const url = await stripeService.createBillingPortal(organizationId);
+  return c.json({ url });
+});

package/dist/plugins/payments/files/src/modules/billing/services/stripe.service.ts

@@ -0,0 +1,47 @@
+import Stripe from 'stripe';
+
+export class StripeService {
+  private stripe: Stripe;
+
+  constructor(apiKey: string) {
+    this.stripe = new Stripe(apiKey, {
+      apiVersion: '2023-10-16' as any,
+    });
+  }
+
+  async createCheckoutSession(customerId: string, priceId: string) {
+    try {
+      return await this.stripe.checkout.sessions.create({
+        customer: customerId,
+        line_items: [{ price: priceId, quantity: 1 }],
+        mode: 'subscription',
+        success_url: '{{SUCCESS_URL}}',
+        cancel_url: '{{CANCEL_URL}}',
+      });
+    } catch (error: any) {
+      console.error(`[StripeService] Checkout session failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async createBillingPortal(customerId: string) {
+    try {
+      return await this.stripe.billingPortal.sessions.create({
+        customer: customerId,
+        return_url: '{{RETURN_URL}}',
+      });
+    } catch (error: any) {
+      console.error(`[StripeService] Billing portal creation failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async handleWebhook(body: string, signature: string, secret: string) {
+    try {
+      return this.stripe.webhooks.constructEvent(body, signature, secret);
+    } catch (error: any) {
+      console.error(`[StripeService] Webhook construction failed: ${error.message}`);
+      throw error;
+    }
+  }
+}

package/dist/plugins/payments/plugin.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "payments",
+  "description": "Stripe integration for subscriptions and one-time payments.",
+  "compatibleTemplates": ["saas", "marketplace", "booking", "crm"],
+  "dependencies": ["auth"],
+  "packageDependencies": {
+    "stripe": "latest",
+    "zod": "^3.22.4"
+  }
+}

package/dist/plugins/queue/files/src/modules/queue/services/queue.service.ts

@@ -0,0 +1,61 @@
+import { Queue, Worker, Job } from 'bullmq';
+import Redis from 'ioredis';
+import { EventBus } from '../../../../../../../core/src/hooks/event-bus';
+
+export class QueueService {
+  private redis: Redis;
+  private queue: Queue;
+  private worker: Worker;
+
+  constructor(private eventBus: EventBus) {
+    this.redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379');
+    
+    // Define the default queue for background tasks
+    this.queue = new Queue('default-queue', { connection: this.redis as any });
+
+    // Initialize the background worker
+    this.worker = new Worker('default-queue', async (job: Job) => {
+      console.log(`Processing job ${job.id} of type ${job.name} with data`, job.data);
+      
+      // If the job type is an event bridge trigger
+      if (job.name === 'trigger_event') {
+        this.eventBus.dispatch(job.data.eventName, job.data.payload);
+      }
+      
+      // Add more specific job processors here as needed
+    }, { connection: this.redis as any });
+
+    this.worker.on('completed', (job: Job) => {
+      console.log(`Job ${job.id} has completed successfully.`);
+    });
+
+    this.worker.on('failed', (job: Job | undefined, err: Error) => {
+      console.log(`Job ${job?.id} has failed with error: ${err.message}`);
+    });
+  }
+
+  /**
+   * Enqueue a job to be processed in the background
+   */
+  async addJob(name: string, data: any, opts?: any) {
+    try {
+      return await this.queue.add(name, data, opts);
+    } catch (error: any) {
+      console.error(`[QueueService] Failed to add job ${name}: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Gracefully close connections
+   */
+  async close() {
+    try {
+      await this.worker.close();
+      await this.queue.close();
+      await this.redis.quit();
+    } catch (error: any) {
+      console.error(`[QueueService] Failed to close connections: ${error.message}`);
+    }
+  }
+}

package/dist/plugins/queue/plugin.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "queue",
+  "description": "Background Jobs and Task Queue powered by BullMQ and Redis.",
+  "compatibleTemplates": ["saas", "marketplace", "crm"],
+  "packageDependencies": {
+    "bullmq": "^5.7.0",
+    "ioredis": "^5.3.0"
+  },
+  "packageDevDependencies": {}
+}

package/dist/plugins/search/files/src/modules/search/services/search.service.ts

@@ -0,0 +1,98 @@
+import { MeiliSearch } from 'meilisearch';
+
+export interface SearchDriver {
+  search(index: string, query: string, options?: any): Promise<any>;
+  addDocuments(index: string, documents: any[]): Promise<any>;
+  deleteDocuments(index: string, documentIds: string[] | number[]): Promise<any>;
+}
+
+export class MeiliSearchDriver implements SearchDriver {
+  private client: MeiliSearch;
+
+  constructor(config: { host: string; apiKey: string }) {
+    this.client = new MeiliSearch(config);
+  }
+
+  async search(index: string, query: string, options: any = {}) {
+    try {
+      return await this.client.index(index).search(query, options);
+    } catch (error: any) {
+      console.error(`[MeiliSearchDriver] Search failed for index ${index}: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async addDocuments(index: string, documents: any[]) {
+    try {
+      return await this.client.index(index).addDocuments(documents);
+    } catch (error: any) {
+      console.error(`[MeiliSearchDriver] Add documents failed for index ${index}: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async deleteDocuments(index: string, documentIds: string[] | number[]) {
+    try {
+      return await this.client.index(index).deleteDocuments(documentIds);
+    } catch (error: any) {
+      console.error(`[MeiliSearchDriver] Delete documents failed for index ${index}: ${error.message}`);
+      throw error;
+    }
+  }
+}
+
+/**
+ * PostgresSearchDriver
+ * Simple fallback using basic SQL pattern matching.
+ */
+export class PostgresSearchDriver implements SearchDriver {
+  constructor(private db: any) {}
+
+  async search(index: string, query: string, _options: any = {}) {
+    // In a real implementation, this would use Drizzle's ilike or tsvector
+    // For the template, we provide the architectural skeleton
+    console.warn(`Postgres Search fallback for index: ${index}`);
+    return {
+      hits: [],
+      query,
+      fallback: true
+    };
+  }
+
+  async addDocuments(_index: string, _documents: any[]) {
+    // No-op for the simple driver, or sync to table if needed
+    return { success: true };
+  }
+
+  async deleteDocuments(_index: string, _documentIds: any[]) {
+    return { success: true };
+  }
+}
+
+export class SearchService {
+  private driver: SearchDriver;
+
+  constructor(config: { 
+    type: 'meilisearch' | 'postgres', 
+    meiliConfig?: { host: string; apiKey: string },
+    db?: any 
+  }) {
+    if (config.type === 'meilisearch' && config.meiliConfig) {
+      this.driver = new MeiliSearchDriver(config.meiliConfig);
+    } else {
+      this.driver = new PostgresSearchDriver(config.db);
+    }
+  }
+
+  async search(index: string, query: string, options: any = {}) {
+    return await this.driver.search(index, query, options);
+  }
+
+  async addDocuments(index: string, documents: any[]) {
+    return await this.driver.addDocuments(index, documents);
+  }
+
+  async deleteDocuments(index: string, documentIds: any[]) {
+    return await this.driver.deleteDocuments(index, documentIds);
+  }
+}

package/dist/plugins/search/plugin.config.json

@@ -0,0 +1,9 @@
+{
+  "name": "search",
+  "description": "Full-text search abstraction with support for PostgreSQL and MeiliSearch.",
+  "compatibleTemplates": ["saas", "marketplace", "cms"],
+  "packageDependencies": {
+    "meilisearch": "latest",
+    "zod": "^3.22.4"
+  }
+}

package/dist/plugins/websocket/files/src/modules/websocket/services/ws.service.ts

@@ -0,0 +1,51 @@
+import { EventBus } from '../../../../../../../core/src/hooks/event-bus';
+
+export class WebSocketService {
+  private clients: Set<any>;
+
+  constructor(private eventBus: EventBus) {
+    this.clients = new Set();
+
+    // Listen to all public events that should trigger a frontend notification
+    this.eventBus.on('notification.broadcast', (payload: any) => {
+      this.broadcast(payload);
+    });
+    
+    // Listen to tenant-specific events
+    this.eventBus.on('tenant.event', (payload: any) => {
+      // Logic to filter clients by orgId can be implemented here
+      this.broadcast(payload);
+    });
+  }
+
+  /**
+   * Registers a connected socket
+   */
+  addClient(ws: any) {
+    this.clients.add(ws);
+  }
+
+  /**
+   * Unregisters a disconnected socket
+   */
+  removeClient(ws: any) {
+    this.clients.delete(ws);
+  }
+
+  /**
+   * Broadcasts a message to all connected clients
+   */
+  broadcast(message: any) {
+    const data = JSON.stringify(message);
+    for (const client of this.clients) {
+      // Verify the connection is still open before sending
+      if (typeof client.send === 'function') {
+        try {
+          client.send(data);
+        } catch (err) {
+          console.error('Failed to send message to client', err);
+        }
+      }
+    }
+  }
+}

package/dist/plugins/websocket/plugin.config.json

@@ -0,0 +1,7 @@
+{
+  "name": "websocket",
+  "description": "Real-time WebSockets and Notifications.",
+  "compatibleTemplates": ["saas", "marketplace", "crm"],
+  "packageDependencies": {},
+  "packageDevDependencies": {}
+}

package/dist/templates/templates/saas/files/package.json

@@ -15,7 +15,7 @@
     "zod": "latest",
     "drizzle-orm": "latest",
     "postgres": "latest",
-    "@better-auth/hono": "latest"
+    "better-auth": "latest"
   },
   "devDependencies": {
     "drizzle-kit": "latest",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahmadubaidillah/cli",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "The elite modular boilerplate engine for agentic applications.",
   "repository": {
     "type": "git",
@@ -16,7 +16,7 @@
     "devforge-cli": "dist/bin.js"
   },
   "dependencies": {
-    "@ahmadubaidillah/core": "^1.1.2",
+    "@ahmadubaidillah/core": "^1.1.4",
     "@inquirer/prompts": "latest",
     "chalk": "latest",
     "commander": "latest",