0
# Parse Dashboard
1

2
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.
3

4
## Package Information
5

6
- **Package Name**: parse-dashboard
7
- **Package Type**: npm
8
- **Language**: JavaScript (React + Express.js)
9
- **Installation**: `npm install -g parse-dashboard` (global CLI) or `npm install parse-dashboard` (middleware)
10

11
## Core Imports
12

13
```javascript
14
const ParseDashboard = require('parse-dashboard');
15
const { startServer } = require('parse-dashboard/Parse-Dashboard/server');
16
```
17

18
For ES modules:
19

20
```javascript
21
import ParseDashboard from 'parse-dashboard';
22
```
23

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

26
## Basic Usage
27

28
### Standalone CLI
29

30
```bash
31
parse-dashboard --appId myAppId --masterKey myMasterKey --serverURL http://localhost:1337/parse --appName "My App"
32
```
33

34
### Express Middleware Integration
35

36
```javascript
37
const express = require('express');
38
const ParseDashboard = require('parse-dashboard');
39

40
const dashboard = new ParseDashboard({
41
  apps: [{
42
    serverURL: 'http://localhost:1337/parse',
43
    appId: 'myAppId',
44
    masterKey: 'myMasterKey',
45
    appName: 'My App'
46
  }]
47
});
48

49
const app = express();
50
app.use('/dashboard', dashboard);
51
app.listen(4040);
52
```
53

54
## Architecture
55

56
Parse Dashboard is built around several key components:
57

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

65
## Capabilities
66

67
### CLI Interface
68

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

71
```javascript { .api }
72
// Main CLI command: parse-dashboard [options]
73
// Available options:
74
interface CLIOptions {
75
  appId?: string;           // Parse App ID
76
  masterKey?: string;       // Parse Master Key
77
  serverURL?: string;       // Parse Server URL
78
  dev?: boolean;           // Development mode
79
  config?: string;         // Path to configuration file
80
  host?: string;           // Host to bind (default: 0.0.0.0)
81
  port?: string;           // Port to listen (default: 4040)
82
  allowInsecureHTTP?: boolean;  // Allow HTTP connections
83
  // ... 10+ additional options
84
}
85
```
86

87
[CLI Interface](./cli.md)
88

89
### Express Middleware
90

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

93
```javascript { .api }
94
/**
95
 * Creates Parse Dashboard Express middleware
96
 * @param config - Dashboard configuration object
97
 * @param options - Optional middleware configuration
98
 * @returns Express middleware function
99
 */
100
function ParseDashboard(config: DashboardConfig, options?: MiddlewareOptions): Function;
101

102
interface DashboardConfig {
103
  apps: AppConfig[];
104
  users?: UserConfig[];
105
  agent?: AgentConfig;
106
  useEncryptedPasswords?: boolean;
107
  iconsFolder?: string;
108
  trustProxy?: boolean;
109
  enableResourceCache?: boolean;
110
  enableSecurityChecks?: boolean;
111
}
112

113
interface MiddlewareOptions {
114
  allowInsecureHTTP?: boolean;
115
  cookieSessionSecret?: string;
116
  cookieSessionMaxAge?: number;
117
  dev?: boolean;
118
}
119
```
120

121
[Express Middleware](./middleware.md)
122

123
### Server Function
124

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

127
```javascript { .api }
128
/**
129
 * Creates and starts standalone Parse Dashboard server
130
 * @param options - Server configuration options including CLI options
131
 */
132
function startServer(options: ServerOptions): void;
133

134
interface ServerOptions extends MiddlewareOptions {
135
  host?: string;           // Host to bind (default: 0.0.0.0)
136
  port?: string;           // Port to listen (default: 4040)  
137
  mountPath?: string;      // Mount path (default: /)
138
  sslKey?: string;         // Path to SSL private key
139
  sslCert?: string;        // Path to SSL certificate
140
  trustProxy?: boolean;    // Trust proxy headers
141
  config?: string;         // Path to configuration file
142
  appId?: string;          // Parse App ID (for CLI configuration)
143
  masterKey?: string;      // Parse Master Key (for CLI configuration)
144
  serverURL?: string;      // Parse Server URL (for CLI configuration)
145
  graphQLServerURL?: string;  // GraphQL Server URL (for CLI configuration)
146
  appName?: string;        // App display name (for CLI configuration)
147
  agent?: string;          // JSON string of agent configuration
148
}
149
```
150

151
### Configuration Management
152

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

155
```javascript { .api }
156
interface AppConfig {
157
  serverURL: string;
158
  appId: string;
159
  masterKey: string | (() => string);
160
  appName: string;
161
  graphQLServerURL?: string;
162
  readOnlyMasterKey?: string;
163
  masterKeyTtl?: number;
164
  appNameForURL?: string;    // Custom URL slug for the app
165
  production?: boolean;
166
  iconName?: string;
167
  primaryBackgroundColor?: string;
168
  secondaryBackgroundColor?: string;
169
  columnPreference?: ColumnPreference;
170
  classPreference?: ClassPreference;
171
  scripts?: ScriptConfig[];
172
}
173

174
interface ColumnPreference {
175
  [className: string]: ColumnConfig[];
176
}
177

178
interface ColumnConfig {
179
  name: string;
180
  visible: boolean;
181
  preventSort?: boolean;
182
  filterSortToTop?: boolean;
183
}
184

185
interface ClassPreference {
186
  [className: string]: {
187
    filters?: FilterConfig[];
188
  };
189
}
190

191
interface FilterConfig {
192
  name: string;
193
  filter: FilterConstraint[];
194
}
195

196
interface FilterConstraint {
197
  field: string;
198
  constraint: string;
199
  value?: any;
200
}
201

202
interface ScriptConfig {
203
  title: string;
204
  classes: string[];
205
  cloudCodeFunction: string;
206
  showConfirmationDialog?: boolean;
207
  confirmationDialogStyle?: string;
208
}
209
```
210

211
[Configuration](./configuration.md)
212

213
### Authentication System
214

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

217
```javascript { .api }
218
interface UserConfig {
219
  user: string;
220
  pass: string;
221
  readOnly?: boolean;
222
  apps?: UserAppConfig[];
223
  mfa?: string;
224
  mfaAlgorithm?: string;
225
  mfaDigits?: number;
226
  mfaPeriod?: number;
227
}
228

229
interface UserAppConfig {
230
  appId: string;
231
  readOnly?: boolean;
232
}
233

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

240
interface AuthOptions {
241
  cookieSessionSecret?: string;
242
  cookieSessionMaxAge?: number;
243
  mountPath?: string;
244
}
245

246
interface AuthResult {
247
  isAuthenticated: boolean;
248
  matchingUsername: string | null;
249
  otpMissingLength: number | false;
250
  otpValid: boolean;
251
  appsUserHasAccessTo: UserAppConfig[] | null;
252
  isReadOnly: boolean;
253
}
254
```
255

256
[Authentication](./authentication.md)
257

258
### AI Agent Integration
259

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

262
```javascript { .api }
263
interface AgentConfig {
264
  models: ModelConfig[];
265
}
266

267
interface ModelConfig {
268
  name: string;
269
  provider: string;
270
  model: string;
271
  apiKey: string;
272
}
273

274
// AI Agent API endpoint: POST /apps/:appId/agent
275
interface AgentRequest {
276
  message: string;
277
  modelName: string;
278
  conversationId?: string;
279
  permissions: {
280
    createObject: boolean;
281
    updateObject: boolean;
282
    deleteObject: boolean;
283
    createClass: boolean;
284
    deleteClass: boolean;
285
  };
286
}
287
```
288

289
[AI Agent](./ai-agent.md)