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

Configuration

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

Parse Dashboard uses a comprehensive configuration system that supports multiple Parse Server apps, advanced features, and extensive customization options.

Capabilities

App Configuration

Configuration for individual Parse Server applications:

interface AppConfig {
  /** 
   * Parse Server URL (required)
   * The URL of your Parse Server instance
   */
  serverURL: string;
  
  /**
   * Parse App ID (required)
   * The application identifier for your Parse app
   */
  appId: string;
  
  /**
   * Master Key (required)
   * Can be a string or function that returns the master key
   */
  masterKey: string | (() => string);
  
  /**
   * App display name (required)
   * Human-readable name shown in the dashboard
   */
  appName: string;
  
  /**
   * GraphQL Server URL (optional)
   * URL for GraphQL endpoint if different from serverURL
   */
  graphQLServerURL?: string;
  
  /**
   * Read-only Master Key (optional)
   * Master key with read-only permissions
   */
  readOnlyMasterKey?: string;
  
  /**
   * Master Key TTL (optional)
   * Time-to-live for master key in seconds
   */
  masterKeyTtl?: number;
  
  /**
   * Custom URL slug (optional)
   * Custom identifier for URL paths
   */
  appNameForURL?: string;
  
  /**
   * Production flag (optional)
   * Indicates if this is a production environment
   */
  production?: boolean;
  
  /**
   * App icon filename (optional)
   * Icon file in the iconsFolder
   */
  iconName?: string;
  
  /**
   * Primary background color (optional)
   * CSS color value for app background
   */
  primaryBackgroundColor?: string;
  
  /**
   * Secondary background color (optional)
   * CSS color value for secondary backgrounds
   */
  secondaryBackgroundColor?: string;
  
  /**
   * Column display preferences (optional)
   * Configuration for data browser column behavior
   */
  columnPreference?: ColumnPreference;
  
  /**
   * Class-level preferences (optional)
   * Configuration for class-specific features
   */
  classPreference?: ClassPreference;
  
  /**
   * Custom scripts (optional)
   * Cloud Function scripts available in the dashboard
   */
  scripts?: ScriptConfig[];
}

Column Preferences

Configuration for data browser column display and behavior:

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

interface ColumnConfig {
  /**
   * Column/field name
   */
  name: string;
  
  /**
   * Whether column is visible by default
   */
  visible: boolean;
  
  /**
   * Prevent sorting on this column
   */
  preventSort?: boolean;
  
  /**
   * Sort this column to top in filter popup
   */
  filterSortToTop?: boolean;
}

Class Preferences

Configuration for class-specific features and persistent filters:

interface ClassPreference {
  [className: string]: {
    /**
     * Persistent filters for the class
     */
    filters?: FilterConfig[];
  };
}

interface FilterConfig {
  /**
   * Filter display name
   */
  name: string;
  
  /**
   * Filter constraints
   */
  filter: FilterConstraint[];
}

interface FilterConstraint {
  /**
   * Field name to filter on
   */
  field: string;
  
  /**
   * Constraint type (eq, ne, lt, gt, etc.)
   */
  constraint: string;
  
  /**
   * Filter value (optional)
   */
  value?: any;
}

Script Configuration

Configuration for custom Cloud Function scripts available in the dashboard:

interface ScriptConfig {
  /**
   * Script display title
   */
  title: string;
  
  /**
   * Classes this script applies to
   */
  classes: string[];
  
  /**
   * Cloud Function name to execute
   */
  cloudCodeFunction: string;
  
  /**
   * Show confirmation dialog before execution
   */
  showConfirmationDialog?: boolean;
  
  /**
   * Confirmation dialog style/type
   */
  confirmationDialogStyle?: string;
}

Global Configuration

Top-level configuration object structure:

interface DashboardConfig {
  /**
   * Parse Server applications (required)
   */
  apps: AppConfig[];
  
  /**
   * Dashboard users for authentication (optional)
   */
  users?: UserConfig[];
  
  /**
   * Use encrypted passwords (bcrypt) (optional)
   * Default: false (plain text comparison)
   */
  useEncryptedPasswords?: boolean;
  
  /**
   * Folder containing app icons (optional)
   * Path to directory with icon files
   */
  iconsFolder?: string;
  
  /**
   * Trust proxy headers (optional)
   * Enable when behind reverse proxy
   */
  trustProxy?: boolean;
  
  /**
   * Enable browser resource caching (optional)
   * Default: true
   */
  enableResourceCache?: boolean;
  
  /**
   * Enable security status checks (optional)
   * Default: true
   */
  enableSecurityChecks?: boolean;
  
  /**
   * AI Agent configuration (optional)
   */
  agent?: AgentConfig;
}

Configuration Examples:

// Basic single app configuration
const config = {
  apps: [{
    serverURL: 'http://localhost:1337/parse',
    appId: 'myAppId',
    masterKey: 'myMasterKey',
    appName: 'My Application'
  }]
};

// Multi-app configuration with customization
const multiAppConfig = {
  apps: [
    {
      serverURL: 'http://prod-server.com/parse',
      appId: 'prodAppId',
      masterKey: 'prodMasterKey',
      appName: 'Production App',
      production: true,
      iconName: 'prod-icon.png',
      primaryBackgroundColor: '#1e3a8a',
      readOnlyMasterKey: 'readOnlyKey'
    },
    {
      serverURL: 'http://localhost:1337/parse',
      appId: 'devAppId',
      masterKey: () => process.env.DEV_MASTER_KEY,
      appName: 'Development App',
      production: false,
      iconName: 'dev-icon.png',
      primaryBackgroundColor: '#059669'
    }
  ],
  users: [{
    user: 'admin',
    pass: 'securePassword123'
  }],
  iconsFolder: './dashboard-icons',
  useEncryptedPasswords: true,
  enableSecurityChecks: true
};

// Configuration with column preferences
const configWithPreferences = {
  apps: [{
    serverURL: 'http://localhost:1337/parse',
    appId: 'myAppId',
    masterKey: 'myMasterKey',
    appName: 'My App',
    columnPreference: {
      'User': [
        { name: 'objectId', visible: false },
        { name: 'username', visible: true, filterSortToTop: true },
        { name: 'email', visible: true },
        { name: 'createdAt', visible: true, preventSort: false }
      ],
      'Post': [
        { name: 'title', visible: true, filterSortToTop: true },
        { name: 'content', visible: true },
        { name: 'author', visible: true }
      ]
    },
    classPreference: {
      'User': {
        filters: [
          {
            name: 'Active Users',
            filter: [
              { field: 'emailVerified', constraint: 'eq', value: true },
              { field: 'createdAt', constraint: 'gte' }
            ]
          }
        ]
      }
    }
  }]
};

// Configuration with custom scripts
const configWithScripts = {
  apps: [{
    serverURL: 'http://localhost:1337/parse',
    appId: 'myAppId',
    masterKey: 'myMasterKey',
    appName: 'My App',
    scripts: [
      {
        title: 'Send Welcome Email',
        classes: ['User'],
        cloudCodeFunction: 'sendWelcomeEmail',
        showConfirmationDialog: true,
        confirmationDialogStyle: 'info'
      },
      {
        title: 'Generate Report',
        classes: ['Order', 'User'],
        cloudCodeFunction: 'generateSalesReport',
        showConfirmationDialog: true
      }
    ]
  }]
};

// Environment-based configuration
const envConfig = {
  apps: [{
    serverURL: process.env.PARSE_SERVER_URL,
    appId: process.env.PARSE_APP_ID,
    masterKey: process.env.PARSE_MASTER_KEY,
    appName: process.env.APP_NAME,
    graphQLServerURL: process.env.GRAPHQL_SERVER_URL,
    production: process.env.NODE_ENV === 'production'
  }],
  users: process.env.DASHBOARD_USERS ? JSON.parse(process.env.DASHBOARD_USERS) : undefined,
  trustProxy: process.env.TRUST_PROXY === 'true',
  enableResourceCache: process.env.ENABLE_CACHE !== 'false'
};

Configuration File Loading

Parse Dashboard can load configuration from JSON files:

parse-dashboard --config ./dashboard-config.json

Example configuration file:

{
  "apps": [
    {
      "serverURL": "http://localhost:1337/parse",
      "appId": "myAppId",
      "masterKey": "myMasterKey",
      "appName": "My Application",
      "production": false
    }
  ],
  "users": [
    {
      "user": "admin",
      "pass": "password123"
    }
  ],
  "useEncryptedPasswords": true,
  "iconsFolder": "./icons"
}

Install with Tessl CLI