tessl/npm-parse-dashboard

A standalone dashboard for managing Parse Server apps with web interface and Express middleware integration

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Express Middleware

Name: tessl/npm-parse-dashboard
Author: tessl

Parse Dashboard can be integrated as Express middleware into existing Node.js applications, providing the full dashboard functionality within your application's routing structure.

Capabilities

ParseDashboard Constructor

Creates Express middleware for Parse Dashboard integration.

/**
 * Creates Parse Dashboard Express middleware
 * @param config - Dashboard configuration object
 * @param options - Optional middleware configuration
 * @returns Express middleware function
 */
function ParseDashboard(config: DashboardConfig, options?: MiddlewareOptions): Function;

// Alternative usage as constructor:
const dashboard = new ParseDashboard(config, options);

Middleware Options

Configuration options specific to middleware integration:

interface MiddlewareOptions {
  /**
   * Allow HTTP connections (disable HTTPS requirement)
   * Use only behind HTTPS proxy or in development
   */
  allowInsecureHTTP?: boolean;
  
  /**
   * Secret key for session cookie encryption
   * Should be a long, random string
   */
  cookieSessionSecret?: string;
  
  /**
   * Session timeout in seconds
   * Default: session expires when browser closes
   */
  cookieSessionMaxAge?: number;
  
  /**
   * Development mode - disables authentication
   * DO NOT USE IN PRODUCTION
   */
  dev?: boolean;
}

Server Function

Standalone server creation function (used internally by CLI):

/**
 * Creates and starts standalone Parse Dashboard server
 * @param options - Server configuration options
 */
function startServer(options: ServerOptions): void;

interface ServerOptions extends MiddlewareOptions {
  host?: string;          // Host to bind (default: 0.0.0.0)
  port?: string;          // Port to listen (default: 4040)
  mountPath?: string;     // Mount path (default: /)
  sslKey?: string;        // Path to SSL private key
  sslCert?: string;       // Path to SSL certificate
  trustProxy?: boolean;   // Trust proxy headers
  config?: string;        // Path to configuration file
  // ... CLI options
}

Usage Examples:

const express = require('express');
const ParseDashboard = require('parse-dashboard');

// Basic middleware integration
const dashboard = new ParseDashboard({
  apps: [{
    serverURL: 'http://localhost:1337/parse',
    appId: 'myAppId',
    masterKey: 'myMasterKey',
    appName: 'My App'
  }]
});

const app = express();
app.use('/dashboard', dashboard);
app.listen(4040);

// With authentication and session configuration
const dashboardWithAuth = new ParseDashboard({
  apps: [{
    serverURL: 'http://localhost:1337/parse',
    appId: 'myAppId',
    masterKey: 'myMasterKey',
    appName: 'My App'
  }],
  users: [{
    user: 'admin',
    pass: 'password123'
  }]
}, {
  allowInsecureHTTP: false,
  cookieSessionSecret: 'my-secret-key-change-this-in-production',
  cookieSessionMaxAge: 3600000 // 1 hour
});

app.use('/admin/dashboard', dashboardWithAuth);

// Multiple Parse Server apps
const multiAppDashboard = new ParseDashboard({
  apps: [
    {
      serverURL: 'http://localhost:1337/parse',
      appId: 'app1',
      masterKey: 'masterKey1',
      appName: 'Production App',
      production: true
    },
    {
      serverURL: 'http://localhost:1338/parse',
      appId: 'app2',
      masterKey: 'masterKey2',
      appName: 'Development App',
      production: false
    }
  ]
});

// Development mode (no authentication)
const devDashboard = new ParseDashboard({
  apps: [{
    serverURL: 'http://localhost:1337/parse',
    appId: 'myAppId',
    masterKey: 'myMasterKey',
    appName: 'My App'
  }]
}, {
  dev: true,
  allowInsecureHTTP: true
});

// SSL configuration (when not using reverse proxy)
const secureDashboard = new ParseDashboard({
  apps: [{ /* app config */ }],
  users: [{ /* user config */ }]
}, {
  allowInsecureHTTP: false,
  cookieSessionSecret: process.env.SESSION_SECRET
});

// With custom mount path and proxy settings
app.set('trust proxy', true);
app.use('/admin/parse', dashboard);

Integration Patterns

Reverse Proxy Setup

When running behind a reverse proxy (Nginx, Apache, etc.):

const dashboard = new ParseDashboard(config, {
  allowInsecureHTTP: true,  // Proxy handles HTTPS
  cookieSessionSecret: process.env.SESSION_SECRET
});

// Trust proxy headers
app.set('trust proxy', true);
app.use('/dashboard', dashboard);

Environment-based Configuration

const dashboard = new ParseDashboard({
  apps: [{
    serverURL: process.env.PARSE_SERVER_URL,
    appId: process.env.PARSE_APP_ID,
    masterKey: process.env.PARSE_MASTER_KEY,
    appName: process.env.APP_NAME || 'My App'
  }]
}, {
  allowInsecureHTTP: process.env.NODE_ENV === 'development',
  cookieSessionSecret: process.env.DASHBOARD_SESSION_SECRET,
  dev: process.env.NODE_ENV === 'development'
});

Multiple Applications Integration

// Different dashboards for different user roles
const adminDashboard = new ParseDashboard(adminConfig, adminOptions);
const userDashboard = new ParseDashboard(userConfig, userOptions);

app.use('/admin/dashboard', adminDashboard);
app.use('/user/dashboard', userDashboard);

Types

Dashboard Configuration

interface DashboardConfig {
  apps: AppConfig[];
  users?: UserConfig[];
  agent?: AgentConfig;
  useEncryptedPasswords?: boolean;
  iconsFolder?: string;
  trustProxy?: boolean;
  enableResourceCache?: boolean;
  enableSecurityChecks?: boolean;
}

Install with Tessl CLI