TypeScript nova-base.validate類代碼示例

export async function helloWorldAdapter(this: ActionContext, inputs: any, token: Token): Promise<HelloWorldInputs> {
    validate.input(inputs.author, 'Author must be provided');
    const user = await (this.dao as any).fetchUserById(token.userId);
    validate.authorized(user, 'Authorization required');
    return { 
        user    : user, 
        author  : inputs.author
    };
}

export function parseAuthHeader(header: string): AuthInputs {
    validate.authorized(header, 'Authorization header was not provided');
    const authParts = header.split(' ');
    validate.input(authParts.length === 2, 'Invalid authorization header');
    return {
        scheme      : authParts[0],
        credentials : authParts[1]
    };
}

 authenticator.authenticate = function () {
     try {
         validate.authorized(false, 'Invalid token');
     } catch (e) {
         return Promise.reject(e);
     }
 };

        handlers.push(async function(request: Request, response: Response, next: Function) {
            try {
                // remember current time
                const timestamp = Date.now();

                // build inputs object
                let inputs: any;
                if (config.body && config.body.type === 'files') {
                    inputs = Object.assign({}, config.defaults, request.query, request.params, request.body, { files: request.files });
                }
                else if (config.body && config.body.type === 'multipart') {
                    const filesField = (config.body as MultipartBodyOptions).mapFilesTo;
                    const files = filesField ? { [filesField]: request.files } : undefined;
                    inputs = Object.assign({}, config.defaults, request.query, request.params, request.body, files);
                }
                else {
                    const bodyField = config.body && (config.body as JsonBodyOptions).mapTo;
                    const body = bodyField ? { [bodyField]: request.body } : request.body;
                    inputs = Object.assign({}, config.defaults, request.query, request.params, body);
                }

                // get the executor
                const executor = executorMap.get(inputs[selector]);
                validate.input(!selector || executor, `No actions found for the specified ${selector}`);

                // check authorization header
                let requestor: RequestorInfo;
                const authHeader = request.headers['authorization'] || request.headers['Authorization'];
                if (authHeader) {
                    // if header is present, build and parse auth inputs
                    const authInputs = parseAuthHeader(authHeader);
                    validate(executor.authenticator, 'Cannot authenticate: authenticator is undefined');
                    requestor = {
                        ip  : request.ip,
                        auth: executor.authenticator.decode(authInputs)
                    };
                }
                else {
                    // otherwise, set requestor to the IP address of the request
                    requestor = { ip: request.ip };
                }

                // execute the action
                const result = await executor.execute(inputs, requestor, timestamp);

                // build response
                if (config.response) {
                    let view: any;
                    let viewer: string = requestor.auth
                        ? executor.authenticator.toOwner(requestor.auth)
                        : requestor.ip;

                    if (typeof config.response === 'function') {
                        view = config.response(result, undefined, viewer, timestamp);
                    }
                    else {
                        const viewBuilderOptions = (typeof config.response.options === 'function')
                            ? config.response.options(inputs, result, viewer, timestamp)
                            : config.response.options;
                        view = config.response.view(result, viewBuilderOptions, viewer, timestamp);
                    }

                    if (!view) throw new Exception('Resource not found', HttpStatusCode.NotFound);
                    if (typeof view !== 'object') throw new Exception(`View for ${request.method} ${request.path} returned invalid value`);

                    response.statusCode = HttpStatusCode.OK;
                    const body = JSON.stringify(view);
                    response.setHeader('Content-Type', 'application/json; charset=utf-8');
                    response.setHeader('Content-Length', Buffer.byteLength(body, 'utf8').toString(10));
                    response.end(body, 'utf8');
                }
                else {
                    response.statusCode = HttpStatusCode.NoContent;
                    response.end();
                }
            }
            catch (error) {
                next(error);
            }
        });

    [users[2].id]: users[2],
};

// INTERFACES
// =================================================================================================
export interface Token {
    userId  : string;
    password: string;
}

// AUTHENTICATOR
// =================================================================================================
export const authenticator: Authenticator<Token, Token> = {

    decode(inputs: AuthInputs): Token {
        validate.authorized(inputs.scheme === 'token', 'Authentication schema not supported');
        const parts = inputs.credentials.split('%');
        validate.authorized(parts.length === 2, 'Invalid token');
        return {
            userId  : parts[0],
            password: parts[1]
        }
    },

    authenticate(this: ActionContext, requestor: RequestorInfo, options: any): Promise<Token> {
        try {
            let token = requestor.auth as Token;
            validate.authorized(token, 'Token is undefined');
            const user = USER_MAP[token.userId];
            validate.authorized(user, 'Invalid user');
            validate.authorized(token.password === user.password, 'Invalid password');