export async function createUser(server: Server, request: Request, reply: IReply)
{
    const payload = request.payload as {name: string, username: string, password: string, accountId: string};
    const account = await Accounts.Database.get<Account>(payload.accountId.toLowerCase());

    if (!account)
    {
        return reply(notAcceptable(`No account with id of ${payload.accountId} exists.`));
    }

    // Ensure adding another user won't go over the account's plan limit.
    const userCount = await Users.countByAccountId(payload.accountId.toLowerCase());
    const plan = findPlan(account.planId);
    
    if (userCount >= plan.totalUsers)
    {
        return reply(notAcceptable("Account's plan has reached its maximum number of users."));
    }

    let user: User = {
        _id: payload.username,
        _rev: undefined,
        accountId: payload.accountId.toLowerCase(),
        hashedPassword: hashSync(payload.password, 10),
        name: payload.name,
    }

    try
    {
        const update = await Users.Database.put(user);

        if (!update.ok)
        {
            return reply(expectationFailed("Failed to create user.", update));
        }

        user._rev = update.rev;
    }
    catch (e)
    {
        console.error("Error thrown when creating user", e);

        throw e;
    }

    // Do not reflect the user's hashedPassword.
    user.hashedPassword = undefined;

    return reply(user).code(201);
}

export function getSearchDsl(
  mappings: IndexMapping,
  schema: SavedObjectsSchema,
  options: GetSearchDslOptions
) {
  const {
    type,
    search,
    defaultSearchOperator,
    searchFields,
    sortField,
    sortOrder,
    namespace,
    hasReference,
  } = options;

  if (!type) {
    throw Boom.notAcceptable('type must be specified');
  }

  if (sortOrder && !sortField) {
    throw Boom.notAcceptable('sortOrder requires a sortField');
  }

  return {
    ...getQueryParams(
      mappings,
      schema,
      namespace,
      type,
      search,
      searchFields,
      defaultSearchOperator,
      hasReference
    ),
    ...getSortingParams(mappings, type, sortField, sortOrder),
  };
}

        handler: async function (req, res, next) {
            const query: Requests.GetOauthUrl = req.validatedQuery;
            const isValidUrl = await Auth.isValidShopifyDomain(req.validatedQuery.shop_domain);

            if (!isValidUrl) {
                return next(boom.notAcceptable(`${query.shop_domain} is not a valid Shopify shop domain.`));
            }

            const authUrl = await Auth.buildAuthorizationUrl(Constants.DEFAULT_SCOPES, req.validatedQuery.shop_domain, Constants.SHOPIFY_API_KEY, query.redirect_url);

            res.json({ url: authUrl });

            return next();
        }

  return async function errorHandlerMiddleware(ctx, next) {
    try {
      await next();
      if (ctx.status === 404) throw Boom.notFound();
    } catch (applicationError) {
      const err: ApplicationError = applicationError;
      let error: Boom<any>;

      // Normalize error object
      try {
        if (!(applicationError instanceof Error)) throw new Error('Cannot handle non-errors as errors');
        error = Boom.isBoom(err)
          ? err
          : Boom.boomify(err, {
              statusCode: err.status || err.statusCode || undefined,
              decorate: err.data,
            });
      } catch (subError) {
        error = Boom.boomify(subError);
      }

      // Set defaults
      let status = Boom.notAcceptable().output.statusCode;
      let headers = {};
      let body: string | object = Boom.notAcceptable().output.payload.message;

      // Check for dev and include dev stuff
      if (ctx.app.env !== 'production') {
        error.output.payload.additionalDevelopmentData = {
          data: error.data || undefined,
          stack: error.isServer && error.stack ? error.stack : undefined,
        };
      }

      // Convert boom response to proper format
      const payload = {
        error: {
          code: error.output.payload.code || '',
          status: error.output.payload.statusCode,
          error: error.output.payload.error,
          message: error.output.payload.message,
          errors: error.output.payload.errors,
          additionalDevelopmentData: error.output.payload.additionalDevelopmentData,
        },
      };

      // Respond with the proper format
      const format = ctx.accepts(['json', 'text']);
      if (format === 'json') {
        status = error.output.statusCode;
        headers = error.output.headers;
        body = payload;
      } else if (format === 'text') {
        status = error.output.statusCode;
        headers = error.output.headers;
        body = payload.error.message;
      }

      // Respond with the error
      ctx.set(headers);
      ctx.status = status;
      ctx.body = body;
    }
  };