Required dependencies

npm install express cors express-rate-limit
npm install @parse/fs-files-adapter @parse/push-adapter
npm install @apollo/server @as-integrations/express5
npm install @graphql-tools/merge @graphql-tools/schema @graphql-tools/utils
npm install graphql graphql-list-fields graphql-relay graphql-upload
npm install bcryptjs jsonwebtoken jwks-rsa
npm install ldapjs lru-cache lodash intersect mime
npm install commander follow-redirects
npm install @fastify/busboy
npm install parse mongoose # peer: parse SDK for node
npm install pg pg-promise # if using PostgreSQL adapter
npm install mongodb # if using MongoDB adapter

No native iOS/Android build steps are required. This is a pure Node.js backend block. If deploying with Docker, ensure the Node.js base image is >= 18 (see upstream compatibility matrix).

Project setup

1. Drop the source. Place the source/ directory at the root of your project, or copy its contents into src/parse-server/. Update import paths accordingly.

2. TypeScript config. Ensure tsconfig.json targets at least ES2020 and includes the source directory:

   {
     "compilerOptions": {
       "target": "ES2020",
       "module": "CommonJS",
       "esModuleInterop": true,
       "allowJs": true,
       "outDir": "dist",
       "rootDir": "src",
       "resolveJsonModule": true
     },
     "include": ["src/**/*"]
   }
   

3. Babel (if not using tsc directly). Add @babel/preset-typescript and @babel/preset-env with modules: "commonjs".

4. Environment variables. The server reads options passed programmatically, but conventional env vars used in Cloud Code and adapters include:

   PARSE_SERVER_APPLICATION_ID=myAppId
   PARSE_SERVER_MASTER_KEY=myMasterKey
   PARSE_SERVER_DATABASE_URI=mongodb://localhost:27017/parse
   PARSE_SERVER_URL=http://localhost:1337/parse
   

5. Entry point. Create src/server.ts (see Working Examples below) and compile with tsc or run directly with ts-node.

6. Verify. Hit GET /parse/health – a {"status":"ok"} response confirms the server is running.

Public API

ParseServer

import ParseServer from './source/ParseServer';

const server = new ParseServer(options: ParseServerOptions);
await server.start();
const app: Express = server.app; // mount on your Express app

The main class. Instantiate with a ParseServerOptions object, call start(), then mount server.app on your Express instance. Use ParseServer.createLiveQueryServer(httpServer, options) to attach a LiveQuery WebSocket server to an existing HTTP server.

ParseGraphQLServer

import { ParseGraphQLServer } from './source/GraphQL/ParseGraphQLServer';

const graphQLServer = new ParseGraphQLServer(parseServer, {
  graphQLPath: '/graphql',
  playgroundPath: '/playground',
});
graphQLServer.applyMiddleware({ app }); // app is an Express instance

Wraps the Parse Server instance and attaches Apollo Server middleware to an Express app. Use when you need a GraphQL API in addition to (or instead of) the REST API.

PushWorker

import { PushWorker } from './source/Push/PushWorker';

const worker = new PushWorker(pushAdapter, subscriberConfig);

Processes push notification jobs from the push queue. Instantiate in a separate worker process when running push in a distributed architecture. The queue is backed by PushQueue and uses the configured push adapter (default: @parse/push-adapter).

getControllers

import { getControllers } from './source/Controllers';
import { ParseServerOptions } from './source/Options';

const controllers = getControllers(options: ParseServerOptions);
// returns: { loggerController, filesController, databaseController, ... }

Factory that constructs all server controllers from a ParseServerOptions object. Useful when you need direct access to individual controllers (e.g., databaseController for low-level queries) without spinning up the full HTTP server.

Working examples

Scenario - Minimal standalone server

Stand up a Parse Server on Express with MongoDB and serve REST requests.

import express from 'express';
import ParseServer from './source/ParseServer';
import { ParseServerOptions } from './source/Options';

const options: ParseServerOptions = {
  databaseURI: process.env.PARSE_SERVER_DATABASE_URI || 'mongodb://localhost:27017/dev',
  appId: process.env.PARSE_SERVER_APPLICATION_ID || 'myAppId',
  masterKey: process.env.PARSE_SERVER_MASTER_KEY || 'myMasterKey',
  serverURL: process.env.PARSE_SERVER_URL || 'http://localhost:1337/parse',
  allowClientClassCreation: false,
};

async function main() {
  const app = express();
  const parseServer = new ParseServer(options);
  await parseServer.start();
  app.use('/parse', parseServer.app);
  app.listen(1337, () => console.log('Parse Server running on port 1337'));
}

main().catch(console.error);

Scenario - Adding GraphQL API

Attach the GraphQL playground and endpoint alongside the REST API.

import express from 'express';
import { createServer } from 'http';
import ParseServer from './source/ParseServer';
import { ParseGraphQLServer } from './source/GraphQL/ParseGraphQLServer';
import { ParseServerOptions } from './source/Options';

const options: ParseServerOptions = {
  databaseURI: 'mongodb://localhost:27017/dev',
  appId: 'myAppId',
  masterKey: 'myMasterKey',
  serverURL: 'http://localhost:1337/parse',
};

async function main() {
  const app = express();
  const parseServer = new ParseServer(options);
  await parseServer.start();

  const graphQLServer = new ParseGraphQLServer(parseServer, {
    graphQLPath: '/graphql',
    playgroundPath: '/playground',
  });

  app.use('/parse', parseServer.app);
  graphQLServer.applyMiddleware({ app });

  const httpServer = createServer(app);
  ParseServer.createLiveQueryServer(httpServer, { appId: 'myAppId' });
  httpServer.listen(1337, () => console.log('Ready'));
}

main().catch(console.error);

Scenario - Custom cache adapter and direct controller access

Use the Redis cache adapter and access the database controller directly.

import ParseServer from './source/ParseServer';
import RedisCacheAdapter from './source/Adapters/Cache/RedisCacheAdapter';
import { getControllers } from './source/Controllers';
import { ParseServerOptions } from './source/Options';

const options: ParseServerOptions = {
  databaseURI: 'mongodb://localhost:27017/dev',
  appId: 'myAppId',
  masterKey: 'myMasterKey',
  serverURL: 'http://localhost:1337/parse',
  cacheAdapter: new RedisCacheAdapter({ url: 'redis://localhost:6379' }),
};

// Access controllers without mounting HTTP server
const controllers = getControllers(options);

async function countObjects() {
  const db = controllers.databaseController;
  const results = await db.find('GameScore', {}, { limit: 1000 });
  console.log(`Found ${results.length} GameScore objects`);
}

countObjects().catch(console.error);

Scenario - Schema migration on startup

Apply declarative schema definitions and lock schemas in production.

import ParseServer from './source/ParseServer';
import { ParseServerOptions } from './source/Options';

const options: ParseServerOptions = {
  databaseURI: 'mongodb://localhost:27017/dev',
  appId: 'myAppId',
  masterKey: 'myMasterKey',
  serverURL: 'http://localhost:1337/parse',
  schema: {
    definitions: [
      {
        className: 'GameScore',
        fields: { score: { type: 'Number' }, playerName: { type: 'String' } },
      },
    ],
    strict: true,
    lockSchemas: true,
    deleteExtraFields: false,
    afterMigration: async () => console.log('Schema migration complete'),
  },
};

(async () => {
  const server = new ParseServer(options);
  await server.start();
  console.log('Server started with locked schema');
})();

File walkthrough

• index.ts - Package entry point; re-exports ParseServer, cache adapters, PushWorker, ParseGraphQLServer, AuthAdapter, SchemaMigrations, and TestUtils.
• ParseServer.ts - Bootstraps the Express application, wires all controllers, registers routers and middleware, exposes start(), createLiveQueryServer(), and startApp().
• Options/index.js - Defines ParseServerOptions and sub-interfaces (SchemaOptions, adapter types). The authoritative configuration reference.
• Controllers/index.js - Factory functions (getControllers, getLoggerController, etc.) that construct all runtime controllers from options.
• Adapters/Auth/index.js - Aggregates all built-in auth providers (apple, facebook, google, gcenter, github, ldap, mfa, oauth2, etc.) and exports the auth data manager.
• Adapters/Cache/ - In-memory (InMemoryCacheAdapter), null, Redis (RedisCacheAdapter), and LRU (LRUCacheAdapter) cache implementations.
• Adapters/Files/ - File storage adapters including GridFSBucketAdapter for MongoDB GridFS.
• Adapters/Storage/ - MongoDB and PostgreSQL storage adapters; Postgres/sql/ holds pre-compiled SQL query files via pg-promise.
• GraphQL/ParseGraphQLServer.ts - Apollo Server integration; generates Parse schema and attaches GraphQL middleware to Express.
• Push/PushWorker.js - Dequeues and dispatches push notification jobs; designed for worker-process deployment.
• LiveQuery/ - Server-side LiveQuery engine over WebSockets; subscribes clients to query result changes.
• Routers/ - One Express router per REST resource (classes, users, sessions, files, hooks, schema, etc.).
• triggers.js - Cloud Code trigger registry; registers beforeSave, afterSave, beforeFind, etc. handlers.
• rest.js - High-level functions (find, get, create, update, del) used internally by routers and testable in isolation.
• middlewares.js - Express middleware chain: parses Parse headers, resolves auth, enforces client keys, handles CORS.
• Auth.js - Validates authData payloads against registered providers; returns a resolved auth object.
• Config.js - Retrieves the per-request server config by appId from the in-process cache.
• RestWrite.js - Handles all mutation logic: ACL, pointer resolution, triggers, password hashing, session creation.
• RestQuery.js - Handles all query logic: ACL enforcement, include resolution, $relatedTo, pipeline aggregation.
• logger.ts - Exports getLogger() returning a Winston logger instance.
• defaults.js - Default values for all ParseServerOptions fields.
• cryptoUtils.js - Generates secure random tokens and hashes.
• cache.js - Simple in-process store mapping appId to server config.
• TestUtils.js - destroyAllDataWhenTesting() and related helpers for test isolation.
• Security/ - CheckGroup and security audit utilities for CLP/ACL checks.
• SchemaMigrations/ - Migrations export for programmatic schema migration.
• Deprecator/ - Emits structured deprecation warnings for removed or renamed options.
• cli/ - parse-server CLI binary; parses --appId, --masterKey, etc. and calls ParseServer.startApp.
• cloud-code/ - Cloud Code sandbox utilities for executing user-defined Cloud Functions.

Common pitfalls and fixes

• esModuleInterop missing. Mixed CommonJS (require) and ESM (import) in source causes default is not a constructor; set "esModuleInterop": true in tsconfig.json.
• MongoDB driver version mismatch. Parse Server 9.x requires MongoDB driver 6.x; pinning an older mongodb peer causes MongoServerSelectionError; run npm install mongodb@6.
• pg-promise QueryFile errors at startup. The PostgreSQL SQL files in Adapters/Storage/Postgres/sql/ must be present relative to the compiled output; copy the sql/ directory to dist/ as a post-build step or use ts-node with source paths.
• LiveQuery WebSocket port conflicts. createLiveQueryServer attaches to the same HTTP server by default; if you pass a separate port in liveQueryServerOptions, ensure the firewall/load-balancer allows that port.
• Schema strict: true in development. Setting strict: true with lockSchemas: true prevents any new fields; do not enable both in a development environment where the schema is still evolving.
• graphql-upload multipart conflicts. Express 5 + @as-integrations/express5 + graphql-upload requires careful middleware ordering; mount graphqlUploadExpress() before graphQLServer.applyMiddleware() to avoid "request body already consumed" errors.

Vibe-coding prompt template

I have purchased the `parse-community/parse-server` source block (parse-server@9.9.0-alpha.1).
The source is located in the `source/` directory of this project.
The integration guide is in `USAGE.md`.

Please integrate Parse Server into my existing Node.js/TypeScript Express project by doing the following steps:

1. Read `USAGE.md` and `source/index.ts` to understand all public exports.
2. Install all required dependencies listed in the `## Required dependencies` section of `USAGE.md`.
3. Update `tsconfig.json` as described in `## Project setup`.
4. Create `src/server.ts` that imports `ParseServer` from `source/ParseServer`, constructs it with options read from environment variables (`PARSE_SERVER_APPLICATION_ID`, `PARSE_SERVER_MASTER_KEY`, `PARSE_SERVER_DATABASE_URI`, `PARSE_SERVER_URL`), mounts it at `/parse` on my existing Express app, and calls `server.start()`.
5. Optionally attach `ParseGraphQLServer` from `source/GraphQL/ParseGraphQLServer` at `/graphql` if my project has a `USE_GRAPHQL=true` env var.
6. Wire `ParseServer.createLiveQueryServer` to the HTTP server if `USE_LIVE_QUERY=true`.
7. Show me the final `src/server.ts` and any changes to `package.json` and `tsconfig.json`.

Only use symbols and imports that are documented in `USAGE.md` and visible in `source/index.ts`. Do not invent adapter names or option keys.

License and credit

Parse Server is released under the BSD 3-Clause License. See source/LICENSE if present, or refer to the upstream repository for the full license text.

Upstream package: parse-server on npm Upstream repository: github.com/parse-community/parse-server

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

Hướng dẫn cài đặt đầy đủ và prompt tích hợp sẽ mở khóa sau khi mua.

Wabe Open-Source TypeScript Backend as a Service

Automation, Utilities & Developer Tools

Miễn phí