"use strict";

const Parse = require('parse/node').Parse;
const path = require('path');
// These methods handle batch requests.
const batchPath = '/batch';

// Mounts a batch-handler onto a PromiseRouter.
function mountOnto(router) {
  router.route('POST', batchPath, req => {
    return handleBatch(router, req);
  });
}
function parseURL(urlString) {
  try {
    return new URL(urlString);
  } catch (error) {
    return undefined;
  }
}
function makeBatchRoutingPathFunction(originalUrl, serverURL, publicServerURL) {
  serverURL = serverURL ? parseURL(serverURL) : undefined;
  publicServerURL = publicServerURL ? parseURL(publicServerURL) : undefined;
  const apiPrefixLength = originalUrl.length - batchPath.length;
  let apiPrefix = originalUrl.slice(0, apiPrefixLength);
  const makeRoutablePath = function (requestPath) {
    // The routablePath is the path minus the api prefix
    if (requestPath.slice(0, apiPrefix.length) != apiPrefix) {
      throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot route batch path ' + requestPath);
    }
    return path.posix.join('/', requestPath.slice(apiPrefix.length));
  };
  if (serverURL && publicServerURL && serverURL.pathname != publicServerURL.pathname) {
    const localPath = serverURL.pathname;
    const publicPath = publicServerURL.pathname;

    // Override the api prefix
    apiPrefix = localPath;
    return function (requestPath) {
      // Figure out which server url was used by figuring out which
      // path more closely matches requestPath
      const startsWithLocal = requestPath.startsWith(localPath);
      const startsWithPublic = requestPath.startsWith(publicPath);
      const pathLengthToUse = startsWithLocal && startsWithPublic ? Math.max(localPath.length, publicPath.length) : startsWithLocal ? localPath.length : publicPath.length;
      const newPath = path.posix.join('/', localPath, '/', requestPath.slice(pathLengthToUse));

      // Use the method for local routing
      return makeRoutablePath(newPath);
    };
  }
  return makeRoutablePath;
}

// Returns a promise for a {response} object.
// TODO: pass along auth correctly
function handleBatch(router, req) {
  if (!Array.isArray(req.body.requests)) {
    throw new Parse.Error(Parse.Error.INVALID_JSON, 'requests must be an array');
  }

  // The batch paths are all from the root of our domain.
  // That means they include the API prefix, that the API is mounted
  // to. However, our promise router does not route the api prefix. So
  // we need to figure out the API prefix, so that we can strip it
  // from all the subrequests.
  if (!req.originalUrl.endsWith(batchPath)) {
    throw 'internal routing problem - expected url to end with batch';
  }
  const makeRoutablePath = makeBatchRoutingPathFunction(req.originalUrl, req.config.serverURL, req.config.publicServerURL);
  const batch = transactionRetries => {
    let initialPromise = Promise.resolve();
    if (req.body.transaction === true) {
      initialPromise = req.config.database.createTransactionalSession();
    }
    return initialPromise.then(() => {
      const promises = req.body.requests.map(restRequest => {
        const routablePath = makeRoutablePath(restRequest.path);

        // Construct a request that we can send to a handler
        const request = {
          body: restRequest.body,
          config: req.config,
          auth: req.auth,
          info: req.info
        };
        return router.tryRouteRequest(restRequest.method, routablePath, request).then(response => {
          return {
            success: response.response
          };
        }, error => {
          return {
            error: {
              code: error.code,
              error: error.message
            }
          };
        });
      });
      return Promise.all(promises).then(results => {
        if (req.body.transaction === true) {
          if (results.find(result => typeof result.error === 'object')) {
            return req.config.database.abortTransactionalSession().then(() => {
              return Promise.reject({
                response: results
              });
            });
          } else {
            return req.config.database.commitTransactionalSession().then(() => {
              return {
                response: results
              };
            });
          }
        } else {
          return {
            response: results
          };
        }
      }).catch(error => {
        if (error && error.response && error.response.find(errorItem => typeof errorItem.error === 'object' && errorItem.error.code === 251) && transactionRetries > 0) {
          return batch(transactionRetries - 1);
        }
        throw error;
      });
    });
  };
  return batch(5);
}
module.exports = {
  mountOnto,
  makeBatchRoutingPathFunction
};
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","path","batchPath","mountOnto","router","route","req","handleBatch","parseURL","urlString","URL","error","undefined","makeBatchRoutingPathFunction","originalUrl","serverURL","publicServerURL","apiPrefixLength","length","apiPrefix","slice","makeRoutablePath","requestPath","Error","INVALID_JSON","posix","join","pathname","localPath","publicPath","startsWithLocal","startsWith","startsWithPublic","pathLengthToUse","Math","max","newPath","Array","isArray","body","requests","endsWith","config","batch","transactionRetries","initialPromise","Promise","resolve","transaction","database","createTransactionalSession","then","promises","map","restRequest","routablePath","request","auth","info","tryRouteRequest","method","response","success","code","message","all","results","find","result","abortTransactionalSession","reject","commitTransactionalSession","catch","errorItem","module","exports"],"sources":["../src/batch.js"],"sourcesContent":["const Parse = require('parse/node').Parse;\nconst path = require('path');\n// These methods handle batch requests.\nconst batchPath = '/batch';\n\n// Mounts a batch-handler onto a PromiseRouter.\nfunction mountOnto(router) {\n  router.route('POST', batchPath, req => {\n    return handleBatch(router, req);\n  });\n}\n\nfunction parseURL(urlString) {\n  try {\n    return new URL(urlString);\n  } catch (error) {\n    return undefined;\n  }\n}\n\nfunction makeBatchRoutingPathFunction(originalUrl, serverURL, publicServerURL) {\n  serverURL = serverURL ? parseURL(serverURL) : undefined;\n  publicServerURL = publicServerURL ? parseURL(publicServerURL) : undefined;\n\n  const apiPrefixLength = originalUrl.length - batchPath.length;\n  let apiPrefix = originalUrl.slice(0, apiPrefixLength);\n\n  const makeRoutablePath = function (requestPath) {\n    // The routablePath is the path minus the api prefix\n    if (requestPath.slice(0, apiPrefix.length) != apiPrefix) {\n      throw new Parse.Error(Parse.Error.INVALID_JSON, 'cannot route batch path ' + requestPath);\n    }\n    return path.posix.join('/', requestPath.slice(apiPrefix.length));\n  };\n\n  if (serverURL && publicServerURL && serverURL.pathname != publicServerURL.pathname) {\n    const localPath = serverURL.pathname;\n    const publicPath = publicServerURL.pathname;\n\n    // Override the api prefix\n    apiPrefix = localPath;\n    return function (requestPath) {\n      // Figure out which server url was used by figuring out which\n      // path more closely matches requestPath\n      const startsWithLocal = requestPath.startsWith(localPath);\n      const startsWithPublic = requestPath.startsWith(publicPath);\n      const pathLengthToUse =\n        startsWithLocal && startsWithPublic\n          ? Math.max(localPath.length, publicPath.length)\n          : startsWithLocal\n            ? localPath.length\n            : publicPath.length;\n\n      const newPath = path.posix.join('/', localPath, '/', requestPath.slice(pathLengthToUse));\n\n      // Use the method for local routing\n      return makeRoutablePath(newPath);\n    };\n  }\n\n  return makeRoutablePath;\n}\n\n// Returns a promise for a {response} object.\n// TODO: pass along auth correctly\nfunction handleBatch(router, req) {\n  if (!Array.isArray(req.body.requests)) {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, 'requests must be an array');\n  }\n\n  // The batch paths are all from the root of our domain.\n  // That means they include the API prefix, that the API is mounted\n  // to. However, our promise router does not route the api prefix. So\n  // we need to figure out the API prefix, so that we can strip it\n  // from all the subrequests.\n  if (!req.originalUrl.endsWith(batchPath)) {\n    throw 'internal routing problem - expected url to end with batch';\n  }\n\n  const makeRoutablePath = makeBatchRoutingPathFunction(\n    req.originalUrl,\n    req.config.serverURL,\n    req.config.publicServerURL\n  );\n\n  const batch = transactionRetries => {\n    let initialPromise = Promise.resolve();\n    if (req.body.transaction === true) {\n      initialPromise = req.config.database.createTransactionalSession();\n    }\n\n    return initialPromise.then(() => {\n      const promises = req.body.requests.map(restRequest => {\n        const routablePath = makeRoutablePath(restRequest.path);\n\n        // Construct a request that we can send to a handler\n        const request = {\n          body: restRequest.body,\n          config: req.config,\n          auth: req.auth,\n          info: req.info,\n        };\n\n        return router.tryRouteRequest(restRequest.method, routablePath, request).then(\n          response => {\n            return { success: response.response };\n          },\n          error => {\n            return { error: { code: error.code, error: error.message } };\n          }\n        );\n      });\n\n      return Promise.all(promises)\n        .then(results => {\n          if (req.body.transaction === true) {\n            if (results.find(result => typeof result.error === 'object')) {\n              return req.config.database.abortTransactionalSession().then(() => {\n                return Promise.reject({ response: results });\n              });\n            } else {\n              return req.config.database.commitTransactionalSession().then(() => {\n                return { response: results };\n              });\n            }\n          } else {\n            return { response: results };\n          }\n        })\n        .catch(error => {\n          if (\n            error &&\n            error.response &&\n            error.response.find(\n              errorItem => typeof errorItem.error === 'object' && errorItem.error.code === 251\n            ) &&\n            transactionRetries > 0\n          ) {\n            return batch(transactionRetries - 1);\n          }\n          throw error;\n        });\n    });\n  };\n  return batch(5);\n}\n\nmodule.exports = {\n  mountOnto,\n  makeBatchRoutingPathFunction,\n};\n"],"mappings":"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","ignoreList":[]}