@celljs/mvc 3.0.0

package/src/node/resolver/method-args-resolver-provider.ts

@@ -0,0 +1,21 @@
+import { Component, Autowired, Prioritizeable } from '@celljs/core';
+import { MethodArgsResolver } from './resolver-protocol';
+
+@Component()
+export class MethodArgsResolverProvider {
+
+    protected prioritized: MethodArgsResolver[];
+
+    constructor(
+        @Autowired(MethodArgsResolver)
+        protected readonly methodArgsResolvers: MethodArgsResolver[]
+    ) { }
+
+    provide(): MethodArgsResolver[] {
+        if (!this.prioritized) {
+            this.prioritized = Prioritizeable.prioritizeAllSync(this.methodArgsResolvers).map(c => c.value);
+        }
+        return this.prioritized;
+    }
+
+}

package/src/node/resolver/method-args-resolver.ts

@@ -0,0 +1,119 @@
+import { MethodArgsResolver } from './resolver-protocol';
+import { Context } from '@celljs/web/lib/node';
+import { Component } from '@celljs/core';
+import {
+    RequestHeaderMetadata,
+    ParamMetadata,
+    QueryMetadata,
+    RequestCookieMetadata,
+    RequestSessionMetadata,
+    BodyMetadata
+} from '../annotation';
+import {PATH_PARMAS_ATTR, RouteMetadata} from '../handler';
+
+@Component(MethodArgsResolver)
+export class BodyMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 100;
+    async resolve(metadata: any, args: any[]): Promise<void> {
+        const body: any = Context.getCurrent().request.body;
+        const bodyMetadatas = <BodyMetadata[]>metadata.bodyMetadata;
+        if (bodyMetadatas && body !== undefined) {
+            for (const m of bodyMetadatas) {
+                args[m.parameterIndex] = m.name ? body[m.name] : body;
+            }
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class HeaderMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 200;
+    async resolve(metadata: any, args: any[]): Promise<void> {
+        const headerMetadatas = <RequestHeaderMetadata[]>metadata.requestHeaderMetadata;
+        if (headerMetadatas) {
+            const request = Context.getCurrent().request;
+            for (const m of headerMetadatas) {
+                args[m.parameterIndex] = m.name ? request.get(m.name) : request.headers;
+            }
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class ParamMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 300;
+
+    async resolve(metadata: any, args: any[]): Promise<void> {
+        const params: any = Context.getAttr(PATH_PARMAS_ATTR);
+        const paramMetadatas = <ParamMetadata[]>metadata.paramMetadata;
+        if (paramMetadatas && params) {
+            for (const m of paramMetadatas) {
+                args[m.parameterIndex] = m.name ? params[m.name] : params;
+            }
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class QueryMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 400;
+    async resolve(metadata: any, args: any[]): Promise<void> {
+        const query: any = Context.getCurrent().request.query;
+        const queryMetadatas = <QueryMetadata[]>metadata.queryMetadata;
+        if (queryMetadatas && query !== undefined) {
+            for (const m of queryMetadatas) {
+                args[m.parameterIndex] = m.name ? query[m.name] : query;
+            }
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class CookieMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 500;
+    async resolve(metadata: any, args: any[]): Promise<void> {
+        const cookies = Context.getCookies();
+        const cookieMetadatas = <RequestCookieMetadata[]>metadata.requestCookieMetadata;
+        if (cookieMetadatas && cookies !== undefined) {
+            for (const m of cookieMetadatas) {
+                args[m.parameterIndex] = m.name ? cookies.get(m.name) : cookies;
+            }
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class SessionMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 600;
+    async resolve(metadata: any, args: any[]): Promise<void> {
+        const session = Context.getSession();
+        const sessionMetadatas = <RequestSessionMetadata[]>metadata.requestSessionMetadata;
+        if (sessionMetadatas && session !== undefined) {
+            for (const m of sessionMetadatas) {
+                args[m.parameterIndex] = m.name ? session[m.name] : session;
+            }
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class RequestMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 700;
+    async resolve(metadata: RouteMetadata, args: any[]): Promise<void> {
+        const requestMetadata = metadata.requestMetadata;
+        if (requestMetadata) {
+            args[requestMetadata.parameterIndex] = Context.getRequest();
+        }
+    }
+}
+
+@Component(MethodArgsResolver)
+export class ResponseMethodArgsResolver implements MethodArgsResolver {
+    readonly priority = 800;
+    async resolve(metadata: RouteMetadata, args: any[]): Promise<void> {
+        const responseMetadata = metadata.responseMetadata;
+        if (responseMetadata) {
+            args[responseMetadata.parameterIndex] = Context.getResponse();
+        }
+    }
+}

package/src/node/resolver/resolver-protocol.ts

@@ -0,0 +1,18 @@
+
+export const MethodArgsResolver = Symbol('MethodArgsResolver');
+export const ResponseResolver = Symbol('ResponseResolver');
+export const ViewResolver = Symbol('ViewResolver');
+
+export interface MethodArgsResolver {
+    readonly priority: number;
+    resolve(metadata: any, args: any[]): Promise<void>;
+}
+
+export interface ResponseResolver {
+    readonly priority: number;
+    resolve(metadata: any): Promise<void>;
+}
+
+export interface ViewResolver {
+    resolve(metadata: any, model: any): Promise<void>;
+}

package/src/node/resolver/response-resolver-provider.ts

@@ -0,0 +1,21 @@
+import { Component, Autowired, Prioritizeable } from '@celljs/core';
+import { ResponseResolver } from './resolver-protocol';
+
+@Component()
+export class ResponseResolverProvider {
+
+    protected prioritized: ResponseResolver[];
+
+    constructor(
+        @Autowired(ResponseResolver)
+        protected readonly responseResolvers: ResponseResolver[]
+    ) { }
+
+    provide(): ResponseResolver[] {
+        if (!this.prioritized) {
+            this.prioritized = Prioritizeable.prioritizeAllSync(this.responseResolvers).map(c => c.value);
+        }
+        return this.prioritized;
+    }
+
+}

package/src/node/resolver/response-resolver.ts

@@ -0,0 +1,46 @@
+import { ResponseResolver } from './resolver-protocol';
+import { Context } from '@celljs/web/lib/node';
+import { Component } from '@celljs/core';
+import { ResponseHeaderMetadata, ResponseCookieMetadata, ResponseSessionMetadata } from '../annotation';
+
+@Component(ResponseResolver)
+export class HeaderResponseResolver implements ResponseResolver {
+    readonly priority = 500;
+    async resolve(metadata: any): Promise<void> {
+        const response = Context.getCurrent().response;
+        const headerMetadatas = <ResponseHeaderMetadata[]>metadata.responseHeaderMetadata;
+        if (headerMetadatas) {
+            for (const m of headerMetadatas) {
+                response.setHeader(m.name, m.value);
+            }
+        }
+    }
+}
+
+@Component(ResponseResolver)
+export class CookieResponseResolver implements ResponseResolver {
+    readonly priority = 500;
+    async resolve(metadata: any): Promise<void> {
+        const cookies = Context.getCookies();
+        const cookieMetadatas = <ResponseCookieMetadata[]>metadata.responseCookieMetadata;
+        if (cookieMetadatas && cookies) {
+            for (const m of cookieMetadatas) {
+                cookies.set(m.name, m.value);
+            }
+        }
+    }
+}
+
+@Component(ResponseResolver)
+export class SessionResponseResolver implements ResponseResolver {
+    readonly priority = 500;
+    async resolve(metadata: any): Promise<void> {
+        const session = Context.getSession();
+        const sessionMetadatas = <ResponseSessionMetadata[]>metadata.responseSessionMetadata;
+        if (sessionMetadatas && session) {
+            for (const m of sessionMetadatas) {
+                session[m.name] = m.value;
+            }
+        }
+    }
+}

package/src/node/resolver/view-resolver-provider.ts

@@ -0,0 +1,21 @@
+import { Component, Autowired, Prioritizeable } from '@celljs/core';
+import { ViewResolver } from './resolver-protocol';
+
+@Component()
+export class ViewResolverProvider {
+
+    protected prioritized: ViewResolver[];
+
+    constructor(
+        @Autowired(ViewResolver)
+        protected readonly viewResolvers: ViewResolver[]
+    ) { }
+
+    provide(): ViewResolver[] {
+        if (!this.prioritized) {
+            this.prioritized = Prioritizeable.prioritizeAllSync(this.viewResolvers).map(c => c.value);
+        }
+        return this.prioritized;
+    }
+
+}

package/src/node/resolver/view-resolver.ts

@@ -0,0 +1,29 @@
+import { ViewResolver } from './resolver-protocol';
+import { Component, Autowired, Value } from '@celljs/core';
+import { ViewProvider } from '../view/view-provider';
+import { ViewMetadata } from '../annotation/view';
+import { Context } from '@celljs/web/lib/node';
+import { HttpHeaders } from '@celljs/http';
+
+@Component(ViewResolver)
+export class ViewResolverImpl implements ViewResolver {
+
+    @Value('cell.mvc.defaultViewName')
+    protected readonly defaultViewName: string;
+
+    @Autowired(ViewProvider)
+    protected readonly viewProvider: ViewProvider;
+
+    async resolve(metadata: any, model: any): Promise<void> {
+        const viewMetadata = <ViewMetadata>metadata.viewMetadata;
+        viewMetadata.viewName = viewMetadata.viewName || this.defaultViewName;
+        for (const view of this.viewProvider.provide()) {
+            if (await view.support(viewMetadata)) {
+                Context.getResponse().setHeader(HttpHeaders.CONTENT_TYPE, view.contentType);
+                await view.render(model, viewMetadata);
+                return;
+            }
+        }
+        throw new Error('Not found a suitable view.');
+    }
+}

package/src/node/view/file-view.ts

@@ -0,0 +1,68 @@
+import { Autowired, Component, Logger, Value } from '@celljs/core';
+import { View } from './view-protocol';
+import { HttpHeaders, HttpStatus, MediaType } from '@celljs/http';
+import { Context, Response } from '@celljs/web/lib/node';
+import { Stream } from 'stream';
+import { FILE_VIEW_NAME } from '../annotation/file';
+import { ViewMetadata } from '../annotation/view';
+import { createReadStream } from 'fs-extra';
+import { join } from 'path';
+
+@Component(View)
+export class FileView implements View {
+
+    readonly contentType = MediaType.APPLICATION_OCTET_STREAM;
+
+    readonly priority = 600;
+
+    @Autowired(Logger)
+    protected readonly logger: Logger;
+
+    @Value('cell.mvc.baseFileDir')
+    protected readonly baseFileDir: any;
+
+    protected isStream(model: any) {
+        return typeof model === 'object'
+            && typeof model.pipe === 'function';
+    }
+
+    async render(model: any, { metadata }: ViewMetadata): Promise<void> {
+        if (metadata?.file) {
+            model = createReadStream(join(__dirname, this.baseFileDir, metadata.file));
+        }
+        const response = Context.getCurrent().response;
+        if (this.isStream(model)) {
+            Context.setSkipAutoEnd(true);
+            this.streamDownload(response, model);
+        } else {
+            if (Buffer.isBuffer(model)) {
+                response.setHeader(HttpHeaders.CONTENT_LENGTH, model.byteLength);
+            }
+            response.body = model;
+        }
+    }
+
+    protected streamDownload(response: Response, stream: Stream): void {
+        stream.on('error', error => {
+            this.handleError(response, error);
+        });
+        response.on('error', error => {
+            this.handleError(response, error);
+        });
+        response.on('close', () => {
+            if (typeof (stream as any).destroy === 'function') {
+                (stream as any).destroy();
+            }
+        });
+        stream.pipe(response);
+    }
+
+    protected async handleError(response: Response, reason: string | Error, status: number = HttpStatus.INTERNAL_SERVER_ERROR): Promise<void> {
+        this.logger.error(reason);
+        response.status(status).send('Unable to download file.').end();
+    }
+
+    support({ viewName }: ViewMetadata): Promise<boolean> {
+        return Promise.resolve(viewName === FILE_VIEW_NAME);
+    }
+}

package/src/node/view/html-view.ts

@@ -0,0 +1,34 @@
+import { Component, Value } from '@celljs/core';
+import { View } from './view-protocol';
+import { Context } from '@celljs/web/lib/node';
+import { parse, render } from 'mustache';
+import { join } from 'path';
+import { readFile } from 'fs-extra';
+import { ViewMetadata } from '../annotation/view';
+import { HTML_VIEW_NAME } from '../annotation/html';
+import { MediaType } from '@celljs/http';
+
+@Component(View)
+export class HtmlView implements View {
+
+    readonly contentType = MediaType.TEXT_HTML;
+
+    readonly priority = 500;
+
+    @Value('cell.mustache')
+    protected readonly options: any;
+
+    async render(model: any, { metadata }: ViewMetadata): Promise<void> {
+        const response = Context.getCurrent().response;
+        const { baseViewDir, cache } = this.options;
+        const template = await readFile(join(__dirname, baseViewDir, metadata!.file), { encoding: 'utf8' });
+        if (cache) {
+            parse(template);
+        }
+        response.body = render(template, model);
+    }
+
+    support({ viewName, metadata }: ViewMetadata): Promise<boolean> {
+        return Promise.resolve(viewName === HTML_VIEW_NAME && metadata?.file?.endsWith('.mustache'));
+    }
+}

package/src/node/view/index.ts

@@ -0,0 +1,6 @@
+export * from './json-view';
+export * from './text-view';
+export * from './view-provider';
+export * from './html-view';
+export * from './file-view';
+export * from './json-view-template-renderer';

package/src/node/view/json-view-template-renderer.ts

@@ -0,0 +1,23 @@
+import { Component, Value } from '@celljs/core';
+import { JsonViewTemplateRenderer } from './view-protocol';
+
+@Component(JsonViewTemplateRenderer)
+export class JsonViewTemplateRendererImpl implements JsonViewTemplateRenderer {
+
+    @Value('cell.mvc.jsonView.template')
+    protected readonly jsonViewTemplate?: string;
+
+    async render(model?: any, error?: Error): Promise<string> {
+        if (this.jsonViewTemplate) {
+            return this.jsonViewTemplate
+                .replace('{{model}}', JSON.stringify(model))
+                .replace('{{error}}', error?.message ?? '')
+                .replace('{{success}}', error ? 'false' : 'true')
+                .replace('{{code}}', (error as any)?.code ?? (error as any)?.statusCode ?? '');
+        }
+        if (error) {
+            throw error;
+        }
+        return JSON.stringify(model);
+    }
+}

package/src/node/view/json-view.ts

@@ -0,0 +1,26 @@
+import { Autowired, Component } from '@celljs/core';
+import { JsonViewTemplateRenderer, View } from './view-protocol';
+import { Context } from '@celljs/web/lib/node';
+import { ViewMetadata } from '../annotation/view';
+import { JSON_VIEW_NAME } from '../annotation/json';
+import { MediaType } from '@celljs/http';
+
+@Component(View)
+export class JsonView implements View {
+
+    readonly contentType = MediaType.APPLICATION_JSON_UTF8;
+
+    readonly priority = 500;
+
+    @Autowired(JsonViewTemplateRenderer)
+    protected readonly jsonViewTemplateRenderer: JsonViewTemplateRenderer;
+
+    async render(model: any, metadata: ViewMetadata): Promise<void> {
+        const response = Context.getCurrent().response;
+        response.body = await this.jsonViewTemplateRenderer.render(model);
+    }
+
+    support({ viewName }: ViewMetadata): Promise<boolean> {
+        return Promise.resolve(viewName === JSON_VIEW_NAME);
+    }
+}

package/src/node/view/text-view.ts

@@ -0,0 +1,23 @@
+import { Component } from '@celljs/core';
+import { View } from './view-protocol';
+import { Context } from '@celljs/web/lib/node';
+import { ViewMetadata } from '../annotation/view';
+import { TEXT_VIEW_NAME } from '../annotation/text';
+import { MediaType } from '@celljs/http';
+
+@Component(View)
+export class TextView implements View {
+
+    readonly contentType = MediaType.TEXT_PLAIN;
+
+    readonly priority = 600;
+
+    async render(model: any, metadata: ViewMetadata): Promise<void> {
+        const response = Context.getCurrent().response;
+        response.body = model;
+    }
+
+    support({ viewName }: ViewMetadata): Promise<boolean> {
+        return Promise.resolve(viewName === TEXT_VIEW_NAME);
+    }
+}

package/src/node/view/view-protocol.ts

@@ -0,0 +1,14 @@
+import { ViewMetadata } from '../annotation/view';
+
+export const View = Symbol('View');
+export const JsonViewTemplateRenderer = Symbol('JsonViewTemplateRenderer');
+
+export interface View {
+    readonly contentType: string;
+    render(model: any, metadata: ViewMetadata): Promise<void>;
+    support(metadata: ViewMetadata): Promise<boolean>;
+}
+
+export interface JsonViewTemplateRenderer {
+    render(model?: any, error?: Error): Promise<string>;
+}

package/src/node/view/view-provider.ts

@@ -0,0 +1,21 @@
+import { Component, Autowired, Prioritizeable } from '@celljs/core';
+import { View } from './view-protocol';
+
+@Component()
+export class ViewProvider {
+
+    protected prioritized: View[];
+
+    constructor(
+        @Autowired(View)
+        protected readonly views: View[]
+    ) { }
+
+    provide(): View[] {
+        if (!this.prioritized) {
+            this.prioritized = Prioritizeable.prioritizeAllSync(this.views).map(c => c.value);
+        }
+        return this.prioritized;
+    }
+
+}

package/src/package.spec.ts

@@ -0,0 +1,4 @@
+describe('mvc package', () => {
+
+    it('support code coverage statistics', () => {});
+});