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

Parse Dashboard

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

Parse Dashboard is a standalone web application dashboard for managing Parse Server apps. It provides a comprehensive interface for database administration, cloud code management, push notifications, user authentication, and configuration management. The dashboard can be deployed as a standalone application or integrated as Express middleware into existing Node.js applications.

Package Information

Package Name: parse-dashboard
Package Type: npm
Language: JavaScript (React + Express.js)
Installation: npm install -g parse-dashboard (global CLI) or npm install parse-dashboard (middleware)

Core Imports

const ParseDashboard = require('parse-dashboard');
const { startServer } = require('parse-dashboard/Parse-Dashboard/server');

For ES modules:

import ParseDashboard from 'parse-dashboard';

Note: The startServer function is used internally by the CLI but can also be imported for programmatic server creation.

Basic Usage

Standalone CLI

parse-dashboard --appId myAppId --masterKey myMasterKey --serverURL http://localhost:1337/parse --appName "My App"

Express Middleware Integration

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

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);

Architecture

Parse Dashboard is built around several key components:

Express Middleware: Factory function that creates dashboard middleware for integration into Express applications
CLI Interface: Command-line tool with comprehensive configuration options and environment variable support
Authentication System: Multi-user authentication with support for basic auth, MFA (TOTP), and read-only access controls
Configuration Management: Complex nested configuration system supporting multiple Parse Server apps and advanced features
AI Agent Integration: OpenAI-powered assistant for natural language database operations
Web Interface: React-based dashboard providing full Parse Server management capabilities

Capabilities

CLI Interface

Command-line interface for running Parse Dashboard as a standalone application with comprehensive configuration options and environment variable support.

// Main CLI command: parse-dashboard [options]
// Available options:
interface CLIOptions {
  appId?: string;           // Parse App ID
  masterKey?: string;       // Parse Master Key
  serverURL?: string;       // Parse Server URL
  dev?: boolean;           // Development mode
  config?: string;         // Path to configuration file
  host?: string;           // Host to bind (default: 0.0.0.0)
  port?: string;           // Port to listen (default: 4040)
  allowInsecureHTTP?: boolean;  // Allow HTTP connections
  // ... 10+ additional options
}

CLI Interface

Express Middleware

Factory function for creating Parse Dashboard middleware that can be integrated into existing Express applications.

/**
 * 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;

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

interface MiddlewareOptions {
  allowInsecureHTTP?: boolean;
  cookieSessionSecret?: string;
  cookieSessionMaxAge?: number;
  dev?: boolean;
}

Express Middleware

Server Function

Standalone server function for creating and starting a Parse Dashboard server (used by CLI).

/**
 * Creates and starts standalone Parse Dashboard server
 * @param options - Server configuration options including CLI 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
  appId?: string;          // Parse App ID (for CLI configuration)
  masterKey?: string;      // Parse Master Key (for CLI configuration)
  serverURL?: string;      // Parse Server URL (for CLI configuration)
  graphQLServerURL?: string;  // GraphQL Server URL (for CLI configuration)
  appName?: string;        // App display name (for CLI configuration)
  agent?: string;          // JSON string of agent configuration
}

Configuration Management

Comprehensive configuration system supporting multiple Parse Server apps, authentication, features, and advanced customization options.

interface AppConfig {
  serverURL: string;
  appId: string;
  masterKey: string | (() => string);
  appName: string;
  graphQLServerURL?: string;
  readOnlyMasterKey?: string;
  masterKeyTtl?: number;
  appNameForURL?: string;    // Custom URL slug for the app
  production?: boolean;
  iconName?: string;
  primaryBackgroundColor?: string;
  secondaryBackgroundColor?: string;
  columnPreference?: ColumnPreference;
  classPreference?: ClassPreference;
  scripts?: ScriptConfig[];
}

interface ColumnPreference {
  [className: string]: ColumnConfig[];
}

interface ColumnConfig {
  name: string;
  visible: boolean;
  preventSort?: boolean;
  filterSortToTop?: boolean;
}

interface ClassPreference {
  [className: string]: {
    filters?: FilterConfig[];
  };
}

interface FilterConfig {
  name: string;
  filter: FilterConstraint[];
}

interface FilterConstraint {
  field: string;
  constraint: string;
  value?: any;
}

interface ScriptConfig {
  title: string;
  classes: string[];
  cloudCodeFunction: string;
  showConfirmationDialog?: boolean;
  confirmationDialogStyle?: string;
}

Configuration

Authentication System

Multi-user authentication system with support for basic authentication, multi-factor authentication (TOTP), and read-only access controls.

interface UserConfig {
  user: string;
  pass: string;
  readOnly?: boolean;
  apps?: UserAppConfig[];
  mfa?: string;
  mfaAlgorithm?: string;
  mfaDigits?: number;
  mfaPeriod?: number;
}

interface UserAppConfig {
  appId: string;
  readOnly?: boolean;
}

class Authentication {
  constructor(validUsers: UserConfig[], useEncryptedPasswords: boolean, mountPath: string);
  initialize(app: Express.Application, options: AuthOptions): void;
  authenticate(userToTest: any, usernameOnly?: boolean): AuthResult;
}

interface AuthOptions {
  cookieSessionSecret?: string;
  cookieSessionMaxAge?: number;
  mountPath?: string;
}

interface AuthResult {
  isAuthenticated: boolean;
  matchingUsername: string | null;
  otpMissingLength: number | false;
  otpValid: boolean;
  appsUserHasAccessTo: UserAppConfig[] | null;
  isReadOnly: boolean;
}

Authentication

AI Agent Integration

OpenAI-powered AI assistant that provides natural language interface for database operations and Parse Server management.

interface AgentConfig {
  models: ModelConfig[];
}

interface ModelConfig {
  name: string;
  provider: string;
  model: string;
  apiKey: string;
}

// AI Agent API endpoint: POST /apps/:appId/agent
interface AgentRequest {
  message: string;
  modelName: string;
  conversationId?: string;
  permissions: {
    createObject: boolean;
    updateObject: boolean;
    deleteObject: boolean;
    createClass: boolean;
    deleteClass: boolean;
  };
}

AI Agent

Install with Tessl CLI