95430bb4e8
* Use LRU cache as default mechanism for caching in memory * Return null as what’s expected
418 lines
16 KiB
JavaScript
418 lines
16 KiB
JavaScript
// ParseServer - open-source compatible API Server for Parse apps
|
|
|
|
var batch = require('./batch'),
|
|
bodyParser = require('body-parser'),
|
|
express = require('express'),
|
|
middlewares = require('./middlewares'),
|
|
Parse = require('parse/node').Parse,
|
|
path = require('path'),
|
|
url = require('url'),
|
|
authDataManager = require('./Adapters/Auth');
|
|
|
|
import defaults from './defaults';
|
|
import * as logging from './logger';
|
|
import AppCache from './cache';
|
|
import Config from './Config';
|
|
import PromiseRouter from './PromiseRouter';
|
|
import requiredParameter from './requiredParameter';
|
|
import { AnalyticsRouter } from './Routers/AnalyticsRouter';
|
|
import { ClassesRouter } from './Routers/ClassesRouter';
|
|
import { FeaturesRouter } from './Routers/FeaturesRouter';
|
|
import { InMemoryCacheAdapter } from './Adapters/Cache/InMemoryCacheAdapter';
|
|
import { AnalyticsController } from './Controllers/AnalyticsController';
|
|
import { CacheController } from './Controllers/CacheController';
|
|
import { AnalyticsAdapter } from './Adapters/Analytics/AnalyticsAdapter';
|
|
import { WinstonLoggerAdapter } from './Adapters/Logger/WinstonLoggerAdapter';
|
|
import { FilesController } from './Controllers/FilesController';
|
|
import { FilesRouter } from './Routers/FilesRouter';
|
|
import { FunctionsRouter } from './Routers/FunctionsRouter';
|
|
import { GlobalConfigRouter } from './Routers/GlobalConfigRouter';
|
|
import { GridStoreAdapter } from './Adapters/Files/GridStoreAdapter';
|
|
import { HooksController } from './Controllers/HooksController';
|
|
import { HooksRouter } from './Routers/HooksRouter';
|
|
import { IAPValidationRouter } from './Routers/IAPValidationRouter';
|
|
import { InstallationsRouter } from './Routers/InstallationsRouter';
|
|
import { loadAdapter } from './Adapters/AdapterLoader';
|
|
import { LiveQueryController } from './Controllers/LiveQueryController';
|
|
import { LoggerController } from './Controllers/LoggerController';
|
|
import { LogsRouter } from './Routers/LogsRouter';
|
|
import { ParseLiveQueryServer } from './LiveQuery/ParseLiveQueryServer';
|
|
import { PublicAPIRouter } from './Routers/PublicAPIRouter';
|
|
import { PushController } from './Controllers/PushController';
|
|
import { PushQueue } from './Push/PushQueue';
|
|
import { PushWorker } from './Push/PushWorker';
|
|
import { PushRouter } from './Routers/PushRouter';
|
|
import { CloudCodeRouter } from './Routers/CloudCodeRouter';
|
|
import { RolesRouter } from './Routers/RolesRouter';
|
|
import { SchemasRouter } from './Routers/SchemasRouter';
|
|
import { SessionsRouter } from './Routers/SessionsRouter';
|
|
import { UserController } from './Controllers/UserController';
|
|
import { UsersRouter } from './Routers/UsersRouter';
|
|
import { PurgeRouter } from './Routers/PurgeRouter';
|
|
import { AudiencesRouter } from './Routers/AudiencesRouter';
|
|
|
|
import DatabaseController from './Controllers/DatabaseController';
|
|
import SchemaCache from './Controllers/SchemaCache';
|
|
import ParsePushAdapter from 'parse-server-push-adapter';
|
|
import MongoStorageAdapter from './Adapters/Storage/Mongo/MongoStorageAdapter';
|
|
import PostgresStorageAdapter from './Adapters/Storage/Postgres/PostgresStorageAdapter';
|
|
|
|
import { ParseServerRESTController } from './ParseServerRESTController';
|
|
// Mutate the Parse object to add the Cloud Code handlers
|
|
addParseCloud();
|
|
|
|
// ParseServer works like a constructor of an express app.
|
|
// The args that we understand are:
|
|
// "analyticsAdapter": an adapter class for analytics
|
|
// "filesAdapter": a class like GridStoreAdapter providing create, get,
|
|
// and delete
|
|
// "loggerAdapter": a class like WinstonLoggerAdapter providing info, error,
|
|
// and query
|
|
// "jsonLogs": log as structured JSON objects
|
|
// "databaseURI": a uri like mongodb://localhost:27017/dbname to tell us
|
|
// what database this Parse API connects to.
|
|
// "cloud": relative location to cloud code to require, or a function
|
|
// that is given an instance of Parse as a parameter. Use this instance of Parse
|
|
// to register your cloud code hooks and functions.
|
|
// "appId": the application id to host
|
|
// "masterKey": the master key for requests to this app
|
|
// "collectionPrefix": optional prefix for database collection names
|
|
// "fileKey": optional key from Parse dashboard for supporting older files
|
|
// hosted by Parse
|
|
// "clientKey": optional key from Parse dashboard
|
|
// "dotNetKey": optional key from Parse dashboard
|
|
// "restAPIKey": optional key from Parse dashboard
|
|
// "webhookKey": optional key from Parse dashboard
|
|
// "javascriptKey": optional key from Parse dashboard
|
|
// "push": optional key from configure push
|
|
// "sessionLength": optional length in seconds for how long Sessions should be valid for
|
|
|
|
class ParseServer {
|
|
|
|
constructor({
|
|
appId = requiredParameter('You must provide an appId!'),
|
|
masterKey = requiredParameter('You must provide a masterKey!'),
|
|
appName,
|
|
analyticsAdapter,
|
|
filesAdapter,
|
|
push,
|
|
scheduledPush = false,
|
|
loggerAdapter,
|
|
jsonLogs = defaults.jsonLogs,
|
|
logsFolder = defaults.logsFolder,
|
|
verbose = defaults.verbose,
|
|
logLevel = defaults.level,
|
|
silent = defaults.silent,
|
|
databaseURI = defaults.DefaultMongoURI,
|
|
databaseOptions,
|
|
databaseAdapter,
|
|
cloud,
|
|
collectionPrefix = '',
|
|
clientKey,
|
|
javascriptKey,
|
|
dotNetKey,
|
|
restAPIKey,
|
|
webhookKey,
|
|
fileKey,
|
|
userSensitiveFields = [],
|
|
enableAnonymousUsers = defaults.enableAnonymousUsers,
|
|
allowClientClassCreation = defaults.allowClientClassCreation,
|
|
oauth = {},
|
|
auth = {},
|
|
serverURL = requiredParameter('You must provide a serverURL!'),
|
|
maxUploadSize = defaults.maxUploadSize,
|
|
verifyUserEmails = defaults.verifyUserEmails,
|
|
preventLoginWithUnverifiedEmail = defaults.preventLoginWithUnverifiedEmail,
|
|
emailVerifyTokenValidityDuration,
|
|
accountLockout,
|
|
passwordPolicy,
|
|
cacheAdapter,
|
|
emailAdapter,
|
|
publicServerURL,
|
|
customPages = {
|
|
invalidLink: undefined,
|
|
verifyEmailSuccess: undefined,
|
|
choosePassword: undefined,
|
|
passwordResetSuccess: undefined
|
|
},
|
|
liveQuery = {},
|
|
sessionLength = defaults.sessionLength, // 1 Year in seconds
|
|
expireInactiveSessions = defaults.expireInactiveSessions,
|
|
revokeSessionOnPasswordReset = defaults.revokeSessionOnPasswordReset,
|
|
schemaCacheTTL = defaults.schemaCacheTTL, // cache for 5s
|
|
cacheTTL = defaults.cacheTTL, // cache for 5s
|
|
cacheMaxSize = defaults.cacheMaxSize, // 10000
|
|
enableSingleSchemaCache = false,
|
|
objectIdSize = defaults.objectIdSize,
|
|
__indexBuildCompletionCallbackForTests = () => {},
|
|
}) {
|
|
// verify parse-server is running on node >= 4.6
|
|
if (process.versions.node < '4.6') {
|
|
throw 'You must run parse-server on node >= 4.6. Your current node version is ' + process.versions.node + '.';
|
|
}
|
|
|
|
// Initialize the node client SDK automatically
|
|
Parse.initialize(appId, javascriptKey || 'unused', masterKey);
|
|
Parse.serverURL = serverURL;
|
|
if ((databaseOptions || (databaseURI && databaseURI != defaults.DefaultMongoURI) || collectionPrefix !== '') && databaseAdapter) {
|
|
throw 'You cannot specify both a databaseAdapter and a databaseURI/databaseOptions/collectionPrefix.';
|
|
} else if (!databaseAdapter) {
|
|
databaseAdapter = this.getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions)
|
|
} else {
|
|
databaseAdapter = loadAdapter(databaseAdapter)
|
|
}
|
|
|
|
if (!filesAdapter && !databaseURI) {
|
|
throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.';
|
|
}
|
|
|
|
userSensitiveFields = Array.from(new Set(userSensitiveFields.concat(
|
|
defaults.userSensitiveFields,
|
|
userSensitiveFields
|
|
)));
|
|
|
|
const loggerControllerAdapter = loadAdapter(loggerAdapter, WinstonLoggerAdapter, { jsonLogs, logsFolder, verbose, logLevel, silent });
|
|
const loggerController = new LoggerController(loggerControllerAdapter, appId);
|
|
logging.setLogger(loggerController);
|
|
|
|
const filesControllerAdapter = loadAdapter(filesAdapter, () => {
|
|
return new GridStoreAdapter(databaseURI);
|
|
});
|
|
const filesController = new FilesController(filesControllerAdapter, appId);
|
|
|
|
const pushOptions = Object.assign({}, push);
|
|
const pushQueueOptions = pushOptions.queueOptions || {};
|
|
if (pushOptions.queueOptions) {
|
|
delete pushOptions.queueOptions;
|
|
}
|
|
// Pass the push options too as it works with the default
|
|
const pushAdapter = loadAdapter(pushOptions && pushOptions.adapter, ParsePushAdapter, pushOptions);
|
|
// We pass the options and the base class for the adatper,
|
|
// Note that passing an instance would work too
|
|
const pushController = new PushController();
|
|
const hasPushSupport = !!(pushAdapter && push);
|
|
const hasPushScheduledSupport = hasPushSupport && (scheduledPush === true);
|
|
|
|
const {
|
|
disablePushWorker
|
|
} = pushQueueOptions;
|
|
|
|
const pushControllerQueue = new PushQueue(pushQueueOptions);
|
|
let pushWorker;
|
|
if (!disablePushWorker) {
|
|
pushWorker = new PushWorker(pushAdapter, pushQueueOptions);
|
|
}
|
|
|
|
const emailControllerAdapter = loadAdapter(emailAdapter);
|
|
const userController = new UserController(emailControllerAdapter, appId, { verifyUserEmails });
|
|
|
|
const cacheControllerAdapter = loadAdapter(cacheAdapter, InMemoryCacheAdapter, {appId: appId, ttl: cacheTTL, maxSize: cacheMaxSize });
|
|
const cacheController = new CacheController(cacheControllerAdapter, appId);
|
|
|
|
const analyticsControllerAdapter = loadAdapter(analyticsAdapter, AnalyticsAdapter);
|
|
const analyticsController = new AnalyticsController(analyticsControllerAdapter);
|
|
|
|
const liveQueryController = new LiveQueryController(liveQuery);
|
|
const databaseController = new DatabaseController(databaseAdapter, new SchemaCache(cacheController, schemaCacheTTL, enableSingleSchemaCache));
|
|
const hooksController = new HooksController(appId, databaseController, webhookKey);
|
|
|
|
const dbInitPromise = databaseController.performInitialization();
|
|
|
|
if (Object.keys(oauth).length > 0) {
|
|
/* eslint-disable no-console */
|
|
console.warn('oauth option is deprecated and will be removed in a future release, please use auth option instead');
|
|
if (Object.keys(auth).length > 0) {
|
|
console.warn('You should use only the auth option.');
|
|
}
|
|
/* eslint-enable */
|
|
}
|
|
|
|
auth = Object.assign({}, oauth, auth);
|
|
|
|
AppCache.put(appId, {
|
|
appId,
|
|
masterKey: masterKey,
|
|
serverURL: serverURL,
|
|
collectionPrefix: collectionPrefix,
|
|
clientKey: clientKey,
|
|
javascriptKey: javascriptKey,
|
|
dotNetKey: dotNetKey,
|
|
restAPIKey: restAPIKey,
|
|
webhookKey: webhookKey,
|
|
fileKey: fileKey,
|
|
analyticsController: analyticsController,
|
|
cacheController: cacheController,
|
|
filesController: filesController,
|
|
pushController: pushController,
|
|
loggerController: loggerController,
|
|
hooksController: hooksController,
|
|
userController: userController,
|
|
verifyUserEmails: verifyUserEmails,
|
|
preventLoginWithUnverifiedEmail: preventLoginWithUnverifiedEmail,
|
|
emailVerifyTokenValidityDuration: emailVerifyTokenValidityDuration,
|
|
accountLockout: accountLockout,
|
|
passwordPolicy: passwordPolicy,
|
|
allowClientClassCreation: allowClientClassCreation,
|
|
authDataManager: authDataManager(auth, enableAnonymousUsers),
|
|
appName: appName,
|
|
publicServerURL: publicServerURL,
|
|
customPages: customPages,
|
|
maxUploadSize: maxUploadSize,
|
|
liveQueryController: liveQueryController,
|
|
sessionLength: Number(sessionLength),
|
|
expireInactiveSessions: expireInactiveSessions,
|
|
jsonLogs,
|
|
revokeSessionOnPasswordReset,
|
|
databaseController,
|
|
schemaCacheTTL,
|
|
enableSingleSchemaCache,
|
|
userSensitiveFields,
|
|
pushWorker,
|
|
pushControllerQueue,
|
|
hasPushSupport,
|
|
hasPushScheduledSupport,
|
|
objectIdSize
|
|
});
|
|
|
|
Config.validate(AppCache.get(appId));
|
|
this.config = AppCache.get(appId);
|
|
Config.setupPasswordValidator(this.config.passwordPolicy);
|
|
hooksController.load();
|
|
|
|
// Note: Tests will start to fail if any validation happens after this is called.
|
|
if (process.env.TESTING) {
|
|
__indexBuildCompletionCallbackForTests(dbInitPromise);
|
|
}
|
|
|
|
if (cloud) {
|
|
addParseCloud();
|
|
if (typeof cloud === 'function') {
|
|
cloud(Parse)
|
|
} else if (typeof cloud === 'string') {
|
|
require(path.resolve(process.cwd(), cloud));
|
|
} else {
|
|
throw "argument 'cloud' must either be a string or a function";
|
|
}
|
|
}
|
|
}
|
|
|
|
getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) {
|
|
let protocol;
|
|
try {
|
|
const parsedURI = url.parse(databaseURI);
|
|
protocol = parsedURI.protocol ? parsedURI.protocol.toLowerCase() : null;
|
|
} catch(e) { /* */ }
|
|
switch (protocol) {
|
|
case 'postgres:':
|
|
return new PostgresStorageAdapter({
|
|
uri: databaseURI,
|
|
collectionPrefix,
|
|
databaseOptions
|
|
});
|
|
default:
|
|
return new MongoStorageAdapter({
|
|
uri: databaseURI,
|
|
collectionPrefix,
|
|
mongoOptions: databaseOptions,
|
|
});
|
|
}
|
|
}
|
|
|
|
get app() {
|
|
return ParseServer.app(this.config);
|
|
}
|
|
|
|
handleShutdown() {
|
|
const { adapter } = this.config.databaseController;
|
|
if (adapter && typeof adapter.handleShutdown === 'function') {
|
|
adapter.handleShutdown();
|
|
}
|
|
}
|
|
|
|
static app({maxUploadSize = '20mb', appId}) {
|
|
// This app serves the Parse API directly.
|
|
// It's the equivalent of https://api.parse.com/1 in the hosted Parse API.
|
|
var api = express();
|
|
//api.use("/apps", express.static(__dirname + "/public"));
|
|
// File handling needs to be before default middlewares are applied
|
|
api.use('/', middlewares.allowCrossDomain, new FilesRouter().expressRouter({
|
|
maxUploadSize: maxUploadSize
|
|
}));
|
|
|
|
api.use('/health', (req, res) => res.sendStatus(200));
|
|
|
|
api.use('/', bodyParser.urlencoded({extended: false}), new PublicAPIRouter().expressRouter());
|
|
|
|
api.use(bodyParser.json({ 'type': '*/*' , limit: maxUploadSize }));
|
|
api.use(middlewares.allowCrossDomain);
|
|
api.use(middlewares.allowMethodOverride);
|
|
api.use(middlewares.handleParseHeaders);
|
|
|
|
const appRouter = ParseServer.promiseRouter({ appId });
|
|
api.use(appRouter.expressRouter());
|
|
|
|
api.use(middlewares.handleParseErrors);
|
|
|
|
//This causes tests to spew some useless warnings, so disable in test
|
|
if (!process.env.TESTING) {
|
|
process.on('uncaughtException', (err) => {
|
|
if (err.code === "EADDRINUSE") { // user-friendly message for this common error
|
|
/* eslint-disable no-console */
|
|
console.error(`Unable to listen on port ${err.port}. The port is already in use.`);
|
|
/* eslint-enable no-console */
|
|
process.exit(0);
|
|
} else {
|
|
throw err;
|
|
}
|
|
});
|
|
}
|
|
if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1') {
|
|
Parse.CoreManager.setRESTController(ParseServerRESTController(appId, appRouter));
|
|
}
|
|
return api;
|
|
}
|
|
|
|
static promiseRouter({appId}) {
|
|
const routers = [
|
|
new ClassesRouter(),
|
|
new UsersRouter(),
|
|
new SessionsRouter(),
|
|
new RolesRouter(),
|
|
new AnalyticsRouter(),
|
|
new InstallationsRouter(),
|
|
new FunctionsRouter(),
|
|
new SchemasRouter(),
|
|
new PushRouter(),
|
|
new LogsRouter(),
|
|
new IAPValidationRouter(),
|
|
new FeaturesRouter(),
|
|
new GlobalConfigRouter(),
|
|
new PurgeRouter(),
|
|
new HooksRouter(),
|
|
new CloudCodeRouter(),
|
|
new AudiencesRouter()
|
|
];
|
|
|
|
const routes = routers.reduce((memo, router) => {
|
|
return memo.concat(router.routes);
|
|
}, []);
|
|
|
|
const appRouter = new PromiseRouter(routes, appId);
|
|
|
|
batch.mountOnto(appRouter);
|
|
return appRouter;
|
|
}
|
|
|
|
static createLiveQueryServer(httpServer, config) {
|
|
return new ParseLiveQueryServer(httpServer, config);
|
|
}
|
|
}
|
|
|
|
function addParseCloud() {
|
|
const ParseCloud = require("./cloud-code/Parse.Cloud");
|
|
Object.assign(Parse.Cloud, ParseCloud);
|
|
global.Parse = Parse;
|
|
}
|
|
|
|
export default ParseServer;
|