@qwickapps/server 1.7.0 → 1.7.2

package/src/plugins/qwickbrain/qwickbrain-plugin.ts

@@ -530,6 +530,141 @@ export function createQwickBrainPlugin(config: QwickBrainPluginConfig): Plugin {
           },
         });
 
+        // POST /mcp/query - LLM Query endpoint (auth required, supports streaming)
+        registry.addRoute({
+          method: 'post',
+          path: `${apiPrefix}/query`,
+          pluginId: 'qwickbrain',
+          handler: async (req: Request, res: ExpressResponse) => {
+            // Check authentication
+            const authError = checkAuth(req);
+            if (authError) {
+              res.status(authError.status).json(authError.body);
+              return;
+            }
+
+            const user = getAuthenticatedUser(req);
+
+            // Check rate limits
+            const rateLimitError = checkRateLimits(user?.id);
+            if (rateLimitError) {
+              Object.entries(rateLimitError.headers).forEach(([key, value]) => {
+                res.setHeader(key, value);
+              });
+              res.status(rateLimitError.status).json(rateLimitError.body);
+              return;
+            }
+
+            try {
+              if (!connectionStatus.connected) {
+                res.status(503).json({
+                  error: 'QwickBrain not connected',
+                  details: connectionStatus.error,
+                });
+                return;
+              }
+
+              // Check if streaming is requested
+              const stream = req.query.stream === 'true';
+
+              // Build query string
+              const queryParams = new URLSearchParams();
+              if (stream) {
+                queryParams.set('stream', 'true');
+              }
+              const queryString = queryParams.toString();
+              const path = `/api/v1/query${queryString ? `?${queryString}` : ''}`;
+
+              log('LLM query', { userId: user?.id, streaming: stream, query: req.body.query });
+
+              if (stream) {
+                // Streaming mode: pipe SSE stream from QwickBrain to client
+                const url = `${config.qwickbrainUrl}${path}`;
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+                try {
+                  const fetchResponse = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                      'Content-Type': 'application/json',
+                      'Accept': 'text/event-stream',
+                    },
+                    body: JSON.stringify(req.body),
+                    signal: controller.signal,
+                  });
+
+                  clearTimeout(timeoutId);
+
+                  if (!fetchResponse.ok) {
+                    res.status(fetchResponse.status).json({
+                      error: 'Query failed',
+                      status: fetchResponse.status,
+                    });
+                    return;
+                  }
+
+                  // Set SSE headers
+                  res.setHeader('Content-Type', 'text/event-stream');
+                  res.setHeader('Cache-Control', 'no-cache');
+                  res.setHeader('Connection', 'keep-alive');
+                  res.setHeader('X-Accel-Buffering', 'no');
+
+                  // Pipe the stream
+                  const reader = fetchResponse.body?.getReader();
+                  if (!reader) {
+                    res.status(500).json({ error: 'No response body' });
+                    return;
+                  }
+
+                  const decoder = new TextDecoder();
+
+                  while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    const text = decoder.decode(value, { stream: true });
+                    res.write(text);
+                  }
+
+                  res.end();
+                } catch (error) {
+                  clearTimeout(timeoutId);
+                  throw error;
+                }
+              } else {
+                // Non-streaming mode: proxy JSON response
+                const response = await proxyToQwickBrain(
+                  config.qwickbrainUrl,
+                  path,
+                  {
+                    method: 'POST',
+                    body: req.body,
+                    timeout,
+                  }
+                );
+
+                if (!response.ok) {
+                  const errorText = await response.text();
+                  res.status(response.status).json({
+                    error: 'Query failed',
+                    details: errorText,
+                  });
+                  return;
+                }
+
+                const result = await response.json();
+                res.json(result);
+              }
+            } catch (error) {
+              log('Error executing query', { error: String(error) });
+              res.status(500).json({
+                error: 'Query execution failed',
+                details: error instanceof Error ? error.message : 'Unknown error',
+              });
+            }
+          },
+        });
+
         // GET /mcp/sse - Server-Sent Events endpoint for streaming (auth required)
         registry.addRoute({
           method: 'get',

package/src/plugins/rate-limit/index.ts

@@ -127,8 +127,6 @@ export type {
   CheckLimitOptions,
 } from './types.js';
 
-// UI Components
-export { RateLimitStatusWidget } from './RateLimitStatusWidget.js';
-export { RateLimitManagementPage } from './RateLimitManagementPage.js';
-export type { RateLimitStatusWidgetProps } from './RateLimitStatusWidget.js';
-export type { RateLimitManagementPageProps } from './RateLimitManagementPage.js';
+// UI Components are exported from main package index (@qwickapps/server)
+// Do NOT export here to avoid loading UI dependencies when importing plugins
+

package/src/plugins/subscriptions/index.ts

@@ -50,8 +50,6 @@ export type {
 // Stores
 export { postgresSubscriptionsStore } from './stores/index.js';
 
-// UI Components
-export { SubscriptionsStatusWidget } from './SubscriptionsStatusWidget.js';
-export type { SubscriptionsStatusWidgetProps } from './SubscriptionsStatusWidget.js';
-export { SubscriptionsManagementPage } from './SubscriptionsManagementPage.js';
-export type { SubscriptionsManagementPageProps } from './SubscriptionsManagementPage.js';
+// UI Components are exported from main package index (@qwickapps/server)
+// Do NOT export here to avoid loading UI dependencies when importing plugins
+

package/src/plugins/subscriptions/subscriptions-plugin.ts

@@ -23,22 +23,26 @@ import type {
   UpdateUserSubscriptionInput,
   FeatureLimitResult,
 } from './types.js';
+import { hasPostgres, getPostgres } from '../postgres-plugin.js';
+import { postgresSubscriptionsStore } from './stores/index.js';
 
 // Store instance for helper access
 let currentStore: SubscriptionsStore | null = null;
 let currentConfig: SubscriptionsPluginConfig | null = null;
 
 /**
- * Create the Subscriptions plugin
+ * Create the Subscriptions plugin with smart defaults
+ *
+ * Config is optional - plugin will use defaults and get dependencies from registry.
+ * Gracefully handles missing dependencies with clear log messages.
  */
-export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Plugin {
-  const debug = config.debug || false;
-  const defaultTierSlug = config.defaultTierSlug || 'free';
-  const apiPrefix = config.api?.prefix || '/'; // Framework adds /subscriptions prefix automatically
-
-  function log(message: string, data?: Record<string, unknown>) {
-    if (debug) {
-      console.log(`[SubscriptionsPlugin] ${message}`, data || '');
+export function createSubscriptionsPlugin(config: Partial<SubscriptionsPluginConfig> = {}): Plugin {
+  function log(message: string, data?: Record<string, unknown>, isError = false) {
+    const prefix = '[SubscriptionsPlugin]';
+    if (isError) {
+      console.error(`${prefix} ${message}`, data || '');
+    } else if (config.debug) {
+      console.log(`${prefix} ${message}`, data || '');
     }
   }
 
@@ -48,15 +52,44 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
     version: '1.0.0',
 
     async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('subscriptions');
+
+      // Check for postgres in registry
+      if (!hasPostgres()) {
+        logger.warn('No Database! Subscriptions plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'subscriptions-store',
+          type: 'custom',
+          check: async () => ({
+            healthy: false,
+            details: {
+              error: 'PostgreSQL not available',
+              state: 'disabled',
+            },
+          }),
+        });
+        return;
+      }
+
+      // Smart defaults - get dependencies from registry
+      const store = config.store ?? postgresSubscriptionsStore({
+        pool: () => getPostgres().getPool(),
+        autoCreateTables: true,
+      });
+
+      const debug = config.debug ?? false;
+      const defaultTierSlug = config.defaultTierSlug ?? 'free';
+      const apiPrefix = config.api?.prefix ?? '/subscriptions';
+
       log('Starting subscriptions plugin');
 
       // Initialize the store (creates tables if needed)
-      await config.store.initialize();
+      await store.initialize();
       log('Subscriptions plugin migrations complete');
 
       // Store references for helper access
-      currentStore = config.store;
-      currentConfig = config;
+      currentStore = store;
+      currentConfig = { ...config, store, debug, defaultTierSlug };
 
       // Register health check
       registry.registerHealthCheck({
@@ -64,7 +97,7 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
         type: 'custom',
         check: async () => {
           try {
-            const tiers = await config.store.listTiers(true);
+            const tiers = await store.listTiers(true);
             return {
               healthy: true,
               details: {
@@ -88,14 +121,14 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
           handler: async (req: Request, res: Response) => {
             try {
               const activeOnly = req.query.active !== 'false';
-              const tiers = await config.store.listTiers(activeOnly);
+              const tiers = await store.listTiers(activeOnly);
 
               // Include entitlements if requested
               if (req.query.include === 'entitlements') {
                 const tiersWithEntitlements = await Promise.all(
                   tiers.map(async (tier) => ({
                     ...tier,
-                    entitlements: await config.store.getEntitlementsByTier(tier.id),
+                    entitlements: await store.getEntitlementsByTier(tier.id),
                   }))
                 );
                 return res.json({ tiers: tiersWithEntitlements });
@@ -119,16 +152,16 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
               const { idOrSlug } = req.params;
 
               // Try by ID first, then by slug
-              let tier = await config.store.getTierById(idOrSlug);
+              let tier = await store.getTierById(idOrSlug);
               if (!tier) {
-                tier = await config.store.getTierBySlug(idOrSlug);
+                tier = await store.getTierBySlug(idOrSlug);
               }
 
               if (!tier) {
                 return res.status(404).json({ error: 'Tier not found' });
               }
 
-              const entitlements = await config.store.getEntitlementsByTier(tier.id);
+              const entitlements = await store.getEntitlementsByTier(tier.id);
               res.json({ ...tier, entitlements });
             } catch (error) {
               console.error('[SubscriptionsPlugin] Get tier error:', error);
@@ -151,12 +184,12 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
               }
 
               // Check for duplicate slug
-              const existing = await config.store.getTierBySlug(input.slug);
+              const existing = await store.getTierBySlug(input.slug);
               if (existing) {
                 return res.status(409).json({ error: 'Tier with this slug already exists' });
               }
 
-              const tier = await config.store.createTier(input);
+              const tier = await store.createTier(input);
               res.status(201).json(tier);
             } catch (error) {
               console.error('[SubscriptionsPlugin] Create tier error:', error);
@@ -173,7 +206,7 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
           handler: async (req: Request, res: Response) => {
             try {
               const input: UpdateTierInput = req.body;
-              const tier = await config.store.updateTier(req.params.id, input);
+              const tier = await store.updateTier(req.params.id, input);
 
               if (!tier) {
                 return res.status(404).json({ error: 'Tier not found' });
@@ -200,8 +233,8 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
                 return res.status(400).json({ error: 'entitlements array is required' });
               }
 
-              await config.store.setTierEntitlements(req.params.id, entitlements);
-              const updatedEntitlements = await config.store.getEntitlementsByTier(req.params.id);
+              await store.setTierEntitlements(req.params.id, entitlements);
+              const updatedEntitlements = await store.getEntitlementsByTier(req.params.id);
 
               res.json({ entitlements: updatedEntitlements });
             } catch (error) {
@@ -221,14 +254,14 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
           pluginId: 'subscriptions',
           handler: async (req: Request, res: Response) => {
             try {
-              const subscription = await config.store.getActiveSubscription(req.params.userId);
+              const subscription = await store.getActiveSubscription(req.params.userId);
 
               if (!subscription) {
                 return res.status(404).json({ error: 'No active subscription found' });
               }
 
               // Get entitlements for the tier
-              const entitlements = await config.store.getEntitlementsByTier(subscription.tier_id);
+              const entitlements = await store.getEntitlementsByTier(subscription.tier_id);
 
               res.json({
                 subscription,
@@ -255,14 +288,14 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
 
               if (!input.tier_id) {
                 // Use default tier if not specified
-                const defaultTier = await config.store.getTierBySlug(defaultTierSlug);
+                const defaultTier = await store.getTierBySlug(defaultTierSlug);
                 if (!defaultTier) {
                   return res.status(400).json({ error: 'tier_id is required (no default tier found)' });
                 }
                 input.tier_id = defaultTier.id;
               }
 
-              const subscription = await config.store.createUserSubscription(input);
+              const subscription = await store.createUserSubscription(input);
               res.status(201).json(subscription);
             } catch (error) {
               console.error('[SubscriptionsPlugin] Create subscription error:', error);
@@ -295,13 +328,13 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
           pluginId: 'subscriptions',
           handler: async (req: Request, res: Response) => {
             try {
-              const success = await config.store.cancelSubscription(req.params.id);
+              const success = await store.cancelSubscription(req.params.id);
 
               if (!success) {
                 return res.status(404).json({ error: 'Subscription not found' });
               }
 
-              const subscription = await config.store.getUserSubscriptionById(req.params.id);
+              const subscription = await store.getUserSubscriptionById(req.params.id);
               res.json(subscription);
             } catch (error) {
               console.error('[SubscriptionsPlugin] Cancel subscription error:', error);
@@ -316,7 +349,7 @@ export function createSubscriptionsPlugin(config: SubscriptionsPluginConfig): Pl
 
     async onStop(): Promise<void> {
       log('Stopping subscriptions plugin');
-      await config.store.shutdown();
+      if (currentStore) { await currentStore.shutdown(); };
       currentStore = null;
       currentConfig = null;
       log('Subscriptions plugin stopped');

package/src/plugins/subscriptions/types.ts

@@ -340,10 +340,16 @@ export interface SubscriptionsApiConfig {
 
 /**
  * Subscriptions plugin configuration
+ *
+ * All properties are optional - plugin will use smart defaults:
+ * - store: Postgres subscriptions store using registry's postgres instance
+ * - defaultTierSlug: 'free'
+ * - api.prefix: '/subscriptions'
+ * - debug: false
  */
 export interface SubscriptionsPluginConfig {
-  /** Subscriptions storage backend */
-  store: SubscriptionsStore;
+  /** Subscriptions storage backend (default: postgres subscriptions store from registry) */
+  store?: SubscriptionsStore;
   /** Default tier slug for new users (default: 'free') */
   defaultTierSlug?: string;
   /** Whether to auto-create default subscription for new users */

package/src/plugins/tenants/index.ts

@@ -11,7 +11,7 @@
 export { createTenantsPlugin, getTenantStore, autoCreateUserTenant } from './tenants-plugin.js';
 
 // Store implementations
-export { postgresTenantStore } from './stores/postgres-store.js';
+export { postgresTenantStore, inMemoryTenantStore } from './stores/index.js';
 
 // Types
 export type {