app[config.method.toLowerCase()](config.path, async function (req: RouterRequest, res: RouterResponse, next: NextFunction) {
// Shim the request and response objects with expected properties.
req.domainWithProtocol = `${req.protocol}://${req.hostname}` + (req.hostname === "localhost" ? ":3000" : "");
req.app = Object.assign({registeredRoutes}, req.app);
if (config.bodyValidation) {
const validation = validate(req.body, config.bodyValidation);
if (validation.error) {
const error = badData(validation.error.message, validation.error.details);
return next(error);
}
req.validatedBody = validation.value;
}
if (config.queryValidation) {
const validation = validate(req.query, config.queryValidation);
if (validation.error) {
const error = badData(validation.error.message, validation.error.details);
return next(error);
}
req.validatedQuery = validation.value;
}
if (config.paramValidation) {
const validation = validate(req.params, config.paramValidation);
if (validation.error) {
const error = badData(validation.error.message, validation.error.details);
return next(error);
}
req.validatedParams = validation.value;
}
// Pass control to the route's handler. Handlers can be async, so wrap them in try/catch to handle promise rejections.
try {
const handler = config.handler(req, res, next);
if (handler instanceof Promise) {
await handler;
}
return;
} catch (e) {
return next(e);
}
});
public validate(): boolean {
var res = Joi.validate(this.config, schema);
if (res.error) {
throw res.error;
}
return true;
}
export function createUser(req: Request, res: Response, next: NextFunction) {
const schema = Joi.object().keys({
name: Joi.string().min(3).required(),
email: Joi.string().email().required(),
password: Joi.string().required().regex(passwordRegex),
agreeTos: Joi.boolean().only(true).required(),
referral: Joi.string().email().options({
language: {
key: '{{!label}}',
string: {
email: 'Not valid referral code'
}
}
}).label(' ') // Joi does not allow empty label but space is working
});
if (req.body.referral) {
req.body.referral = base64decode(req.body.referral);
}
const result = Joi.validate(req.body, schema, options);
if (result.error) {
return res.status(422).json(result);
} else {
return next();
}
}
it('required only', () => {
let obj = {
hello: 'world'
};
expect(Joi.validate(obj, this.schema).error).toBeNull();
});
export function joiValidate(value: any, validator: SchemaLike): ValidationError | null {
let validationResult = validate(value, validator, {
abortEarly: false,
allowUnknown: false
});
if (validationResult.error) {
let duplicates: any = {};
validationResult.error.details = validationResult.error.details.filter((detail) => {
if (duplicates[detail.message] || detail.type === "object.allowUnknown")
return false;
else {
duplicates[detail.message] = true;
return true;
}
});
if (validationResult.error.details.length === 0)
return null;
else
return validationResult.error;
}
else
return null;
}
export async function setup(server: Server, request: Request, reply: IReply)
{
let payload = request.payload as {shopUrl: string};
const props: SetupProps = {
title: "Connect your Shopify store.",
shopUrl: payload.shopUrl,
};
const validation = joi.validate(payload, setupValidation);
if (validation.error)
{
props.error = humanizeError(validation.error);
return reply.view("setup/setup.js", props);
}
payload = validation.value;
if (! (await isValidShopifyDomain(payload.shopUrl)))
{
props.error = "It looks like the URL you entered is not a valid Shopify domain.";
return reply.view("setup/setup.js", props);
}
const scopes: Enums.AuthScope[] = ["write_script_tags"]
const redirect = `${getRequestProtocol(request)}://${getDomain(true)}${ConnectRoutes.GetShopify}`.toLowerCase();
const oauthUrl = await buildAuthorizationUrl(scopes, payload.shopUrl, ShopifyApiKey, redirect);
return reply.redirect(oauthUrl);
}
export function validateDevice(state: State, device: Device): Device {
if (device.interfaceIds) {
validateInterfaces(state, device.interfaceIds)
}
const deviceClass = state.deviceClasses[device.deviceClassId]
if (!deviceClass) {
throw raxaError({
type: 'missingDeviceClass',
deviceClassId: device.deviceClassId,
})
}
if (!deviceClass.config) {
if (device.config) throw new Error('no config allowed')
return device
}
const joiSchema = joi.object({
id: joi.string().allow(''),
name: joi.string().required(),
pluginId: joi.string().required(),
deviceClassId: joi.string().required(),
config: propertiesToJoi(deviceClass.config),
interfaceIds: joi.array().items(joi.string().required()),
})
const result = joi.validate(device, joiSchema)
if (result.error) {
throw raxaError({type: 'invalidDevice', joiError: result.error})
}
return result.value
}
set: (v) => {
const vr = joi.validate(v, rule)
if (vr.error) {
throw vr.error
}
descriptor.set(v);
},
private validateInput(envConfig: EnvConfig): EnvConfig {
const envVarsSchema: Joi.ObjectSchema = Joi.object({
NODE_ENV: Joi.string()
.valid(['development', 'production', 'test', 'provision'])
.default('development'),
PORT: Joi.number().default(3000),
JWT_SECRET: Joi.string().required(),
JWT_EXPIRE: Joi.number().default(3600 * 24 * 7),
DB_TYPE: Joi.string().default('mysql'),
DB_HOST: Joi.string().default('localhost'),
DB_PORT: Joi.number().default(3306),
DB_USERNAME: Joi.string().required(),
DB_PASSWORD: Joi.string().required(),
DB_DATABASE_NAME: Joi.string().required(),
});
const { error, value: validatedEnvConfig } = Joi.validate(
envConfig,
envVarsSchema,
);
if (error) {
throw new Error(`Config validation error: ${error.message}`);
}
return validatedEnvConfig;
}
it('required and invalid optional', () => {
let obj = {
hello: 'world',
world: 1
};
expect(Joi.validate(obj, this.schema).error).not.toBeNull();
});
