@qwickapps/server 1.7.1 → 1.8.0

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

@@ -21,7 +21,9 @@ import type {
   EntitlementStats,
 } from './types.js';
 import type { AuthenticatedRequest } from '../auth/types.js';
-import { getCache, type CacheInstance } from '../cache-plugin.js';
+import { getCache, hasCache, type CacheInstance } from '../cache-plugin.js';
+import { hasPostgres, getPostgres } from '../postgres-plugin.js';
+import { postgresEntitlementSource } from './sources/index.js';
 
 // Plugin state
 let primarySource: EntitlementSource | null = null;
@@ -35,67 +37,103 @@ let cacheEnabled = true;
 let cacheVersion = 1;
 
 /**
- * Create the Entitlements plugin
+ * Create the Entitlements 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 createEntitlementsPlugin(config: EntitlementsPluginConfig): Plugin {
-  const debug = config.debug || false;
-  // Routes are mounted under /api by the control panel, so don't include /api in prefix
-  const apiPrefix = config.api?.prefix || ''; // Framework adds /entitlements prefix automatically (empty string to avoid double slash)
-  const apiEnabled = config.api?.enabled !== false;
-  const enableWriteApi = config.api?.enableWrite !== false;
-
-  function log(message: string, data?: Record<string, unknown>) {
-    if (debug) {
-      console.log(`[EntitlementsPlugin] ${message}`, data || '');
+export function createEntitlementsPlugin(config: Partial<EntitlementsPluginConfig> = {}): Plugin {
+  function log(message: string, data?: Record<string, unknown>, isError = false) {
+    const prefix = '[EntitlementsPlugin]';
+    if (isError) {
+      console.error(`${prefix} ${message}`, data || '');
+    } else if (config.debug) {
+      console.log(`${prefix} ${message}`, data || '');
     }
   }
 
-  // Cache key helpers
-  const keys = {
-    entitlements: (email: string) => `${cacheKeyPrefix}user:${email.toLowerCase()}`,
-    mapping: (source: string, id: string) => `${cacheKeyPrefix}mapping:${source}:${id}`,
-  };
-
   return {
     id: 'entitlements',
     name: 'Entitlements',
     version: '1.0.0',
 
     async onStart(_pluginConfig: PluginConfig, registry: PluginRegistry): Promise<void> {
+      const logger = registry.getLogger('entitlements');
+
+      // Check for postgres in registry (needed for default source)
+      if (!hasPostgres()) {
+        logger.warn('No Database! Entitlements plugin disabled.');
+        registry.registerHealthCheck({
+          name: 'entitlements-source',
+          type: 'custom',
+          check: async () => ({
+            healthy: false,
+            details: {
+              error: 'PostgreSQL not available',
+              state: 'disabled',
+            },
+          }),
+        });
+        return;
+      }
+
+      // Smart defaults - get dependencies from registry
+      const source = config.source ?? postgresEntitlementSource({
+        pool: () => getPostgres().getPool(),
+        autoCreateTables: true,
+      });
+
+      const debug = config.debug ?? false;
+      const apiPrefix = config.api?.prefix ?? '/entitlements';
+      const apiEnabled = config.api?.enabled ?? true;
+      const enableWriteApi = config.api?.enableWrite ?? true;
+
       log('Starting entitlements plugin');
 
       // Initialize primary source
-      await config.source.initialize();
-      primarySource = config.source;
-      log('Primary source initialized', { source: config.source.name });
+      await source.initialize();
+      primarySource = source;
+      log('Primary source initialized', { source: source.name });
 
       // Initialize additional sources
       additionalSources = config.additionalSources || [];
-      for (const source of additionalSources) {
-        await source.initialize();
-        log('Additional source initialized', { source: source.name });
+      for (const additionalSource of additionalSources) {
+        await additionalSource.initialize();
+        log('Additional source initialized', { source: additionalSource.name });
       }
 
       // Store config
-      pluginConfig = config;
+      pluginConfig = { ...config, source, debug };
 
-      // Setup caching if enabled
+      // Setup caching if enabled and available
       cacheEnabled = config.cache?.enabled !== false;
       if (cacheEnabled) {
-        try {
-          const instanceName = config.cache?.instanceName || 'default';
-          cacheInstance = getCache(instanceName);
-          cacheKeyPrefix = config.cache?.keyPrefix || 'entitlements:';
-          cacheTtl = config.cache?.ttl || 300;
-          cacheMappingTtl = config.cache?.mappingTtl || cacheTtl * 2;
-          log('Cache configured', { instanceName, prefix: cacheKeyPrefix, ttl: cacheTtl });
-        } catch {
-          log('Cache not available, running without caching');
+        if (hasCache()) {
+          try {
+            const instanceName = config.cache?.instanceName || 'default';
+            cacheInstance = getCache(instanceName);
+            cacheKeyPrefix = config.cache?.keyPrefix || 'entitlements:';
+            cacheTtl = config.cache?.ttl || 300;
+            cacheMappingTtl = config.cache?.mappingTtl || cacheTtl * 2;
+            log('Cache configured', { instanceName, prefix: cacheKeyPrefix, ttl: cacheTtl });
+          } catch {
+            log('Cache instance not available, running without caching');
+            cacheEnabled = false;
+            cacheInstance = null;
+          }
+        } else {
+          log('Cache plugin not available, running without caching');
           cacheEnabled = false;
           cacheInstance = null;
         }
       }
 
+      // Cache key helpers
+      const keys = {
+        entitlements: (email: string) => `${cacheKeyPrefix}user:${email.toLowerCase()}`,
+        mapping: (sourceId: string, id: string) => `${cacheKeyPrefix}mapping:${sourceId}:${id}`,
+      };
+
       // Register health check
       registry.registerHealthCheck({
         name: 'entitlements-source',
@@ -104,8 +142,8 @@ export function createEntitlementsPlugin(config: EntitlementsPluginConfig): Plug
           try {
             // Use source's isHealthy() method if available (avoids API calls)
             // Otherwise just check that source is initialized
-            if (config.source.isHealthy) {
-              const healthy = await config.source.isHealthy();
+            if (source.isHealthy) {
+              const healthy = await source.isHealthy();
               return { healthy };
             }
             // Source is healthy if initialized (we got here means it started)
@@ -145,9 +183,9 @@ export function createEntitlementsPlugin(config: EntitlementsPluginConfig): Plug
             try {
               const sources = [
                 {
-                  name: config.source.name,
-                  description: config.source.description,
-                  readonly: config.source.readonly ?? false,
+                  name: source.name,
+                  description: source.description,
+                  readonly: source.readonly ?? false,
                   primary: true,
                 },
                 ...additionalSources.map((s) => ({
@@ -159,8 +197,8 @@ export function createEntitlementsPlugin(config: EntitlementsPluginConfig): Plug
               ];
 
               res.json({
-                readonly: config.source.readonly ?? false,
-                writeEnabled: enableWriteApi && !config.source.readonly,
+                readonly: source.readonly ?? false,
+                writeEnabled: enableWriteApi && !source.readonly,
                 cacheEnabled,
                 cacheTtl,
                 sources,
@@ -311,7 +349,7 @@ export function createEntitlementsPlugin(config: EntitlementsPluginConfig): Plug
         });
 
         // Write endpoints (grant/revoke) - only if enabled and source is writable
-        if (enableWriteApi && !config.source.readonly) {
+        if (enableWriteApi && !source.readonly) {
           // Grant entitlement
           registry.addRoute({
             method: 'post',

package/src/plugins/entitlements/index.ts

@@ -50,8 +50,6 @@ export type {
   EntitlementStats,
 } from './types.js';
 
-// UI Components
-export { EntitlementsStatusWidget } from './EntitlementsStatusWidget.js';
-export type { EntitlementsStatusWidgetProps } from './EntitlementsStatusWidget.js';
-export { EntitlementsManagementPage } from './EntitlementsManagementPage.js';
-export type { EntitlementsManagementPageProps } from './EntitlementsManagementPage.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/entitlements/types.ts

@@ -200,10 +200,17 @@ export interface EntitlementsApiConfig {
 
 /**
  * Entitlements plugin configuration
+ *
+ * All properties are optional - plugin will use smart defaults:
+ * - source: Postgres entitlement source using registry's postgres instance
+ * - cache: Uses cache from registry if available
+ * - api.prefix: '/entitlements'
+ * - api.enabled: true
+ * - debug: false
  */
 export interface EntitlementsPluginConfig {
-  /** Primary entitlement source */
-  source: EntitlementSource;
+  /** Primary entitlement source (default: postgres source from registry) */
+  source?: EntitlementSource;
 
   /** Additional sources to query (results are merged) */
   additionalSources?: EntitlementSource[];

package/src/plugins/index.ts

@@ -14,7 +14,7 @@ export { createLogsPlugin } from './logs-plugin.js';
 export type { LogsPluginConfig } from './logs-plugin.js';
 
 export { createMaintenancePlugin } from './maintenance-plugin.js';
-export type { MaintenancePluginConfig } from './maintenance-plugin.js';
+export type { MaintenancePluginConfig, SeedTask, SeedTaskHandler } from './maintenance-plugin.js';
 export {
   MaintenanceManagementPage,
   MaintenanceStatusWidget,

package/src/plugins/maintenance/SeedExecutor.tsx

@@ -11,6 +11,8 @@ import React, { useEffect, useRef, useState } from 'react';
 export interface SeedExecutorProps {
   apiPrefix: string;
   seedName: string;
+  seedType?: string;
+  seedOptions?: any;
   onComplete: () => void;
   onCancel: () => void;
 }
@@ -26,6 +28,8 @@ interface OutputLine {
 export const SeedExecutor: React.FC<SeedExecutorProps> = ({
   apiPrefix,
   seedName,
+  seedType = 'file',
+  seedOptions,
   onComplete,
   onCancel,
 }) => {
@@ -63,7 +67,11 @@ export const SeedExecutor: React.FC<SeedExecutorProps> = ({
         headers: {
           'Content-Type': 'application/json',
         },
-        body: JSON.stringify({ name: seedName }),
+        body: JSON.stringify({
+          name: seedName,
+          type: seedType,
+          options: seedOptions,
+        }),
       });
 
       if (!response.ok) {

package/src/plugins/maintenance/SeedList.tsx

@@ -1,7 +1,7 @@
 /**
  * Seed List Component
  *
- * Displays available seed scripts with metadata.
+ * Displays available seed scripts and custom tasks with metadata.
  *
  * Copyright (c) 2025 QwickApps.com. All rights reserved.
  */
@@ -10,10 +10,11 @@ import React, { useEffect, useState } from 'react';
 
 export interface SeedListProps {
   apiPrefix: string;
-  onExecute: (seedName: string) => void;
+  onExecute: (seedName: string, type?: string, options?: any) => void;
 }
 
 interface SeedFile {
+  type: 'file';
   name: string;
   path: string;
   size: number;
@@ -21,8 +22,18 @@ interface SeedFile {
   modifiedAt: string;
 }
 
+interface CustomTask {
+  type: 'task';
+  id: string;
+  name: string;
+  description: string;
+  options?: Record<string, any>;
+}
+
+type SeedItem = SeedFile | CustomTask;
+
 export const SeedList: React.FC<SeedListProps> = ({ apiPrefix, onExecute }) => {
-  const [seeds, setSeeds] = useState<SeedFile[]>([]);
+  const [seeds, setSeeds] = useState<SeedItem[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
@@ -57,6 +68,14 @@ export const SeedList: React.FC<SeedListProps> = ({ apiPrefix, onExecute }) => {
     return new Date(dateString).toLocaleString();
   };
 
+  const isFileType = (item: SeedItem): item is SeedFile => {
+    return item.type === 'file';
+  };
+
+  const isTaskType = (item: SeedItem): item is CustomTask => {
+    return item.type === 'task';
+  };
+
   if (loading) {
     return <div style={{ padding: '20px' }}>Loading seeds...</div>;
   }
@@ -72,55 +91,83 @@ export const SeedList: React.FC<SeedListProps> = ({ apiPrefix, onExecute }) => {
   if (seeds.length === 0) {
     return (
       <div style={{ padding: '20px', color: '#666' }}>
-        No seed scripts found in scripts directory.
+        No seed scripts or tasks found.
       </div>
     );
   }
 
   return (
     <div style={{ padding: '20px' }}>
-      <h3>Available Seed Scripts ({seeds.length})</h3>
+      <h3>Available Seeds & Tasks ({seeds.length})</h3>
       <table style={{ width: '100%', borderCollapse: 'collapse', marginTop: '16px' }}>
         <thead>
           <tr style={{ borderBottom: '2px solid #ddd', textAlign: 'left' }}>
+            <th style={{ padding: '12px' }}>Type</th>
             <th style={{ padding: '12px' }}>Name</th>
-            <th style={{ padding: '12px' }}>Size</th>
-            <th style={{ padding: '12px' }}>Modified</th>
+            <th style={{ padding: '12px' }}>Description</th>
+            <th style={{ padding: '12px' }}>Details</th>
             <th style={{ padding: '12px' }}>Action</th>
           </tr>
         </thead>
         <tbody>
-          {seeds.map((seed) => (
-            <tr key={seed.name} style={{ borderBottom: '1px solid #eee' }}>
-              <td style={{ padding: '12px', fontFamily: 'monospace' }}>
-                {seed.name}
-              </td>
-              <td style={{ padding: '12px' }}>{formatFileSize(seed.size)}</td>
-              <td style={{ padding: '12px', fontSize: '14px', color: '#666' }}>
-                {formatDate(seed.modifiedAt)}
-              </td>
-              <td style={{ padding: '12px' }}>
-                <button
-                  onClick={() => {
-                    if (confirm(`Execute ${seed.name}?`)) {
-                      onExecute(seed.name);
-                    }
-                  }}
-                  style={{
-                    padding: '6px 12px',
-                    backgroundColor: '#1976d2',
-                    color: 'white',
-                    border: 'none',
-                    borderRadius: '4px',
-                    cursor: 'pointer',
-                  }}
-                  data-testid={`execute-${seed.name}`}
-                >
-                  Execute
-                </button>
-              </td>
-            </tr>
-          ))}
+          {seeds.map((seed) => {
+            const itemKey = isFileType(seed) ? seed.name : seed.id;
+            return (
+              <tr key={itemKey} style={{ borderBottom: '1px solid #eee' }}>
+                <td style={{ padding: '12px' }}>
+                  <span
+                    style={{
+                      display: 'inline-block',
+                      padding: '4px 8px',
+                      borderRadius: '4px',
+                      fontSize: '12px',
+                      fontWeight: 'bold',
+                      backgroundColor: isFileType(seed) ? '#e3f2fd' : '#f3e5f5',
+                      color: isFileType(seed) ? '#1976d2' : '#7b1fa2',
+                    }}
+                  >
+                    {isFileType(seed) ? 'FILE' : 'TASK'}
+                  </span>
+                </td>
+                <td style={{ padding: '12px', fontFamily: 'monospace' }}>
+                  {isFileType(seed) ? seed.name : seed.name}
+                </td>
+                <td style={{ padding: '12px', fontSize: '14px', color: '#666' }}>
+                  {isTaskType(seed) ? seed.description : '-'}
+                </td>
+                <td style={{ padding: '12px', fontSize: '14px', color: '#666' }}>
+                  {isFileType(seed)
+                    ? `${formatFileSize(seed.size)} • ${formatDate(seed.modifiedAt)}`
+                    : '-'}
+                </td>
+                <td style={{ padding: '12px' }}>
+                  <button
+                    onClick={() => {
+                      const displayName = isFileType(seed) ? seed.name : seed.name;
+                      if (confirm(`Execute ${displayName}?`)) {
+                        if (isFileType(seed)) {
+                          onExecute(seed.name, 'file');
+                        } else {
+                          onExecute(seed.id, 'task', seed.options);
+                        }
+                      }
+                    }}
+                    style={{
+                      padding: '6px 12px',
+                      backgroundColor: '#1976d2',
+                      color: 'white',
+                      border: 'none',
+                      borderRadius: '4px',
+                      cursor: 'pointer',
+                    }}
+                    data-testid={`execute-${itemKey}`}
+                  >
+                    Execute
+                  </button>
+                </td>
+              </tr>
+            );
+          })}
         </tbody>
       </table>
     </div>

package/src/plugins/maintenance/SeedManagementPage.tsx

@@ -1,7 +1,7 @@
 /**
  * Seed Management Page
  *
- * Main page for managing and executing seed scripts.
+ * Main page for managing and executing seed scripts and custom tasks.
  *
  * Copyright (c) 2025 QwickApps.com. All rights reserved.
  */
@@ -23,9 +23,13 @@ export const SeedManagementPage: React.FC<SeedManagementPageProps> = ({
 }) => {
   const [activeTab, setActiveTab] = useState<Tab>('list');
   const [selectedSeed, setSelectedSeed] = useState<string | null>(null);
+  const [selectedType, setSelectedType] = useState<string>('file');
+  const [selectedOptions, setSelectedOptions] = useState<any>(undefined);
 
-  const handleExecute = (seedName: string) => {
+  const handleExecute = (seedName: string, type: string = 'file', options?: any) => {
     setSelectedSeed(seedName);
+    setSelectedType(type);
+    setSelectedOptions(options);
     setActiveTab('execute');
   };
 
@@ -36,7 +40,7 @@ export const SeedManagementPage: React.FC<SeedManagementPageProps> = ({
   return (
     <PluginManagementPage
       title="Seed Management"
-      description="Manage and execute database seed scripts"
+      description="Manage and execute database seed scripts and custom tasks"
     >
       <div style={{ marginBottom: '20px' }}>
         <button
@@ -51,7 +55,7 @@ export const SeedManagementPage: React.FC<SeedManagementPageProps> = ({
             cursor: 'pointer',
           }}
         >
-          Available Seeds
+          Available Seeds & Tasks
         </button>
         <button
           onClick={() => setActiveTab('history')}
@@ -76,6 +80,8 @@ export const SeedManagementPage: React.FC<SeedManagementPageProps> = ({
         <SeedExecutor
           apiPrefix={apiPrefix}
           seedName={selectedSeed}
+          seedType={selectedType}
+          seedOptions={selectedOptions}
           onComplete={handleExecutionComplete}
           onCancel={() => setActiveTab('list')}
         />

package/src/plugins/maintenance/seed-executor.ts

@@ -40,33 +40,33 @@ const MAX_OUTPUT_SIZE = 100 * 1024;
 /**
  * Validate script path to prevent path traversal attacks
  *
- * @param scriptName - Name of the script (e.g., "seed-products.mjs")
+ * @param scriptPath - Relative path to the script (e.g., "database/001.init.mjs" or "01-Setup/seed-data.mjs")
  * @param scriptsPath - Base path for scripts directory
- * @returns Resolved path if valid, null if invalid
+ * @returns Resolved absolute path if valid, null if invalid
  */
-export function validateScriptPath(scriptName: string, scriptsPath: string): string | null {
-  // Only allow seed-*.mjs pattern
-  if (!/^seed-[a-z0-9-]+\.mjs$/.test(scriptName)) {
+export function validateScriptPath(scriptPath: string, scriptsPath: string): string | null {
+  // Only allow .mjs files
+  if (!scriptPath.endsWith('.mjs')) {
     return null;
   }
 
   // Resolve paths
   const basePath = resolve(scriptsPath);
-  const scriptPath = resolve(basePath, scriptName);
+  const resolvedScriptPath = resolve(basePath, scriptPath);
 
   // Ensure resolved path is within scriptsPath (prevent path traversal)
   // Use relative() for platform-agnostic check (works on Windows and Unix)
-  const relativePath = relative(basePath, scriptPath);
+  const relativePath = relative(basePath, resolvedScriptPath);
   if (relativePath.startsWith('..') || relativePath.includes('../') || relativePath.includes('..\\')) {
     return null;
   }
 
   // Ensure file exists
-  if (!existsSync(scriptPath)) {
+  if (!existsSync(resolvedScriptPath)) {
     return null;
   }
 
-  return scriptPath;
+  return resolvedScriptPath;
 }
 
 /**
@@ -95,30 +95,64 @@ export class SeedExecutor {
    *
    * @param scriptPath - Absolute path to the script
    * @param res - Express response object (for SSE streaming)
+   * @param databaseUrl - Optional database URL to pass to the script
+   * @param projectRoot - Optional project root directory (defaults to script's directory)
    * @returns Promise resolving to execution result
    */
-  async execute(scriptPath: string, res: Response): Promise<SeedExecutionResult> {
+  async execute(scriptPath: string, res: Response, databaseUrl?: string, projectRoot?: string): Promise<SeedExecutionResult> {
     this.startTime = Date.now();
     this.outputBuffer = '';
     this.errorBuffer = '';
     this.outputSize = 0;
 
     return new Promise((resolvePromise, rejectPromise) => {
-      // Spawn Node.js process with minimal environment
-      // Use process.execPath to ensure we use the same node binary as the parent process
-      this.child = spawn(process.execPath, [scriptPath], {
+      // Determine if we need tsx (for .ts/.mts files that import TS modules)
+      // Use tsx for .mjs files too since they might import from TS source
+      const needsTsx = scriptPath.match(/\.(mjs|ts|mts)$/);
+      const execCommand = needsTsx ? 'tsx' : process.execPath;
+      const execArgs = needsTsx ? [scriptPath] : [scriptPath];
+
+      // Spawn process with TypeScript support if needed
+      this.child = spawn(execCommand, execArgs, {
         env: {
+          ...process.env, // Inherit all env vars for tsx to work properly
           NODE_ENV: process.env.NODE_ENV || 'development',
-          DATABASE_URI: process.env.DATABASE_URI,
-          DATABASE_URL: process.env.DATABASE_URL,
+          DATABASE_URI: databaseUrl || process.env.DATABASE_URI,
+          DATABASE_URL: databaseUrl || process.env.DATABASE_URL,
           PAYLOAD_PUBLIC_SERVER_URL: process.env.PAYLOAD_PUBLIC_SERVER_URL,
           NEXT_PUBLIC_SERVER_URL: process.env.NEXT_PUBLIC_SERVER_URL,
           API_URL: process.env.API_URL,
+          PAYLOAD_SECRET: process.env.PAYLOAD_SECRET || 'dev-secret-key-change-in-production',
         },
-        stdio: ['ignore', 'pipe', 'pipe'], // stdin: ignore, stdout: pipe, stderr: pipe
-        cwd: resolve(scriptPath, '..'), // Run from scripts directory
+        stdio: ['pipe', 'pipe', 'pipe'], // stdin: pipe, stdout: pipe, stderr: pipe
+        cwd: projectRoot || resolve(scriptPath, '..'), // Run from project root (or scripts directory if not provided)
       });
 
+      // Auto-answer interactive prompts (like Drizzle's schema push confirmation)
+      // Send 'y\n' every 500ms to handle any prompts that appear
+      const stdinInterval = setInterval(() => {
+        if (this.child && this.child.stdin && !this.child.stdin.destroyed) {
+          try {
+            this.child.stdin.write('y\n');
+          } catch (err) {
+            // Ignore errors - stdin might be closed
+          }
+        }
+      }, 500);
+
+      // Clear interval when process exits
+      const cleanupInterval = () => {
+        clearInterval(stdinInterval);
+        // Close stdin to signal EOF
+        if (this.child && this.child.stdin && !this.child.stdin.destroyed) {
+          try {
+            this.child.stdin.end();
+          } catch (err) {
+            // Ignore errors
+          }
+        }
+      };
+
       // Handle stdout
       this.child.stdout?.on('data', (data: Buffer) => {
         const text = data.toString();
@@ -165,6 +199,8 @@ export class SeedExecutor {
 
       // Handle process exit
       this.child.on('exit', (code, signal) => {
+        cleanupInterval(); // Clean up stdin interval
+
         const exitCode = code ?? (signal ? 1 : 0);
         const duration = Date.now() - this.startTime;
 
@@ -188,6 +224,8 @@ export class SeedExecutor {
 
       // Handle spawn errors
       this.child.on('error', (err: Error) => {
+        cleanupInterval(); // Clean up stdin interval
+
         sendSSEEvent(res, {
           type: 'error',
           data: err.message,
@@ -199,6 +237,7 @@ export class SeedExecutor {
 
       // Handle SSE connection close - terminate child process
       res.on('close', () => {
+        cleanupInterval(); // Clean up stdin interval
         if (this.child && !this.child.killed) {
           this.child.kill('SIGTERM');
         }