bmd-extension 1.6.3

package/src/provider/codeAction/service/codeAction.ts

@@ -0,0 +1,232 @@
+import { FSProvider } from '../../../FsProvider';
+import * as vscode from 'vscode';
+import { getFullTextType } from '../../../util';
+
+export enum ServiceAction {
+    GetLast30 = 'BMD: Get last 30',
+    GetSum = 'BMD: Get sum',
+    GetManyAndCount = 'BMD: Get many and count'
+}
+
+export class ServiceActionProvider implements vscode.CodeActionProvider {
+
+    public static readonly providedCodeActionKinds = [
+        vscode.CodeActionKind.QuickFix
+    ];
+
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        range: any,
+        context: vscode.CodeActionContext
+    ): vscode.CodeAction[] | undefined {
+        if (!this.isServiceClass(document, range)) return
+
+        const insertGetLast30 = this.createServiceFunc(document, range, ServiceAction.GetLast30);
+        const insertGetSum = this.createServiceFunc(document, range, ServiceAction.GetSum);
+        const insertGetManyAndCount = this.createServiceFunc(document, range, ServiceAction.GetManyAndCount);
+
+        return [
+            insertGetManyAndCount,
+            insertGetLast30,
+            insertGetSum
+        ];
+    }
+
+    private isServiceClass(document: vscode.TextDocument, range: vscode.Range) {
+        const start = range.start;
+        const line = document.lineAt(start.line);
+        return line.text.includes('Service') && line.text.includes('class')
+    }
+
+
+
+    private createServiceFunc(document: vscode.TextDocument, range: vscode.Range, typeFunc: ServiceAction): vscode.CodeAction {
+        const service = new vscode.CodeAction(typeFunc, vscode.CodeActionKind.QuickFix);
+        service.command = {
+            command: typeFunc,
+            title: 'Get list with pagination.',
+            tooltip: 'Get list with pagination.',
+            arguments: [document]
+        };
+
+        switch (typeFunc) {
+            case ServiceAction.GetLast30:
+                service.command = {
+                    command: typeFunc,
+                    title: 'Get last 30.',
+                    tooltip: 'Get last 30.',
+                    arguments: [document]
+                };
+                break
+
+            case ServiceAction.GetSum:
+                service.command = {
+                    command: typeFunc,
+                    title: 'Get sum.',
+                    tooltip: 'Get sum.',
+                    arguments: [document]
+                };
+                break
+
+            case ServiceAction.GetManyAndCount:
+                service.command = {
+                    command: typeFunc,
+                    title: 'Get many and count.',
+                    tooltip: 'Get many and count.',
+                    arguments: [document]
+                };
+                break
+
+            default:
+                break;
+
+        }
+
+        return service;
+    }
+
+
+    public async insertServiceFunc(typeFunc: ServiceAction, document: vscode.TextDocument): Promise<void> {
+        const edit = new vscode.WorkspaceEdit();
+        let entity = 'Entity'
+        for (let index = 0; index < document.lineCount; index++) {
+            const line = document.lineAt(index)
+            if (line.text.includes('Service')) {
+                let words = line.text.split(' ')
+                words = words.filter(word => word.includes('Service'))
+                words = words.map(word => word = word.replace('Service', ''))
+                entity = words[0] || 'Entity'
+            }
+            if (line.text.includes('END FILE')) {
+                switch (typeFunc) {
+                    case ServiceAction.GetLast30:
+                        edit.insert(document.uri, new vscode.Position(index - 1, 0), this.generateGetLast30(entity));
+                        break
+
+                    case ServiceAction.GetSum:
+                        edit.insert(document.uri, new vscode.Position(index - 1, 0), await this.generateGetSum(entity));
+                        break
+
+                    case ServiceAction.GetManyAndCount:
+                        edit.insert(document.uri, new vscode.Position(index - 1, 0), this.generateGetManyAndCount(entity));
+                        break
+
+                    default:
+                        break;
+                }
+            }
+        }
+
+        vscode.workspace.applyEdit(edit)
+    }
+
+    private generateGetManyAndCount = (name: string) => {
+        const nameTextTypes = getFullTextType(name)
+        let template = `
+        // =====================GET MANY AND COUNT=====================
+        public async getManyAndCount({ page, limit, search }): Promise<[{{cap}}[], number]> {
+            let where = {{backtick}}{{camel}}.name LIKE '%{{dollar}}{search}%' AND {{camel}}.isDeleted = false{{backtick}}
+    
+            const [{{camel}}, total] = await {{cap}}.createQueryBuilder('{{camel}}')
+                .where(where)
+                .skip((page - 1) * limit)
+                .take(limit)
+                .orderBy('{{camel}}.id', 'DESC')
+                .getManyAndCount()
+    
+            return [{{camel}}, total]
+        }
+        `
+        template = template.replace(/{{upper}}/g, nameTextTypes.upperCase);
+        template = template.replace(/{{camel}}/g, nameTextTypes.camelCase);
+        template = template.replace(/{{cap}}/g, nameTextTypes.classifyCase);
+        template = template.replace(/{{dollar}}/g, '$');
+        template = template.replace(/{{backtick}}/g, '`');
+        return template
+    }
+
+    private generateGetLast30 = (name: string) => {
+        const nameTextTypes = getFullTextType(name)
+        let template = `
+        // =====================GET LAST 30 {{upper}}=====================
+        async get{{cap}}Last30(from: Date = null, to: Date = null) {
+            const { start, end } = getFromToDate(from, to)
+
+            const {{camel}} = await {{cap}}.find({
+                where: {
+                    dateCreated: Between(start, end),
+                },
+                order: { dateCreated: "ASC" },
+            })
+
+            const {{camel}}GroupByDay = {}
+            {{camel}}.map(order => {
+                const date = convertIntToDDMMYY(order.dateCreated)
+                if (!{{camel}}GroupByDay[date]) {
+                    {{camel}}GroupByDay[date] = 0
+                }
+                {{camel}}GroupByDay[date] += 1
+            })
+
+            const reports = []
+            for (const date in {{camel}}GroupByDay) {
+                reports.push({
+                    date,
+                    total: {{camel}}GroupByDay[date],
+                })
+            }
+
+            return reports
+        }
+        `
+        template = template.replace(/{{upper}}/g, nameTextTypes.upperCase);
+        template = template.replace(/{{camel}}/g, nameTextTypes.camelCase);
+        template = template.replace(/{{cap}}/g, nameTextTypes.classifyCase);
+        template = template.replace(/{{dollar}}/g, '$');
+        template = template.replace(/{{backtick}}/g, '`');
+        return template
+    }
+
+    private getPropertiesEntity(name: string): any {
+        const lines = FSProvider.getLinesDocumentInFile(`src/entity/${name}.ts`)
+        if (!lines.length) return
+        const properties = []
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (line.includes('@Column')) {
+                let lineProperty = lines[index + 2]
+                lineProperty = lineProperty.replace(':', '').replace(';', '')
+                const words = lineProperty.split(' ').filter(Boolean)
+                if (words.length > 1 && words[1] == 'number') properties.push(words[0])
+                else continue
+            }
+        }
+        return properties
+    }
+
+    private generateGetSum = async (name: string): Promise<any> => {
+        const properties = this.getPropertiesEntity(name)
+        const nameTextTypes = getFullTextType(name)
+        const result = await vscode.window.showQuickPick(properties, {
+            placeHolder: 'Sum by: ', ignoreFocusOut: true
+        })
+        if (!result) return
+
+        let template = `
+                // =====================GET SUM {{upper}}=====================
+                async getSum{{cap}}(): Promise<number> {
+                    const { sum } = await {{cap}}
+                        .createQueryBuilder('{{camel}}')
+                        .select("sum({{camel}}.${result})", 'sum')
+                        .getRawOne()
+                    return sum
+                }
+                `
+        template = template.replace(/{{upper}}/g, nameTextTypes.upperCase);
+        template = template.replace(/{{camel}}/g, nameTextTypes.camelCase);
+        template = template.replace(/{{cap}}/g, nameTextTypes.classifyCase);
+        return template
+    }
+
+
+}

package/src/provider/completion/CompletionProvider.ts

@@ -0,0 +1,108 @@
+import * as vscode from 'vscode';
+import { getEntityFromFunction, getPropertiesEntity, getRelationsEntityDeeper } from '../codeAction/entity/helper';
+import { getWordBetweenSpace, removePlural, getFullTextType } from '../../util';
+import { FSProvider } from '../../FsProvider';
+
+export const CompletionPropertyProvider = vscode.languages.registerCompletionItemProvider(
+    'typescript',
+    {
+        provideCompletionItems(document: vscode.TextDocument, position: vscode.Position) {
+            const linePrefix = document.lineAt(position).text.substr(0, position.character)
+            if (linePrefix.endsWith('.')) {
+                const lineWithoutEndWithDot = linePrefix.slice(0, -1)
+                let { text } = getWordBetweenSpace(lineWithoutEndWithDot, lineWithoutEndWithDot.length - 1)
+
+                let entity = text
+                let isEntity = FSProvider.isEntity(entity)
+
+                if (!isEntity) {
+                    entity = removePlural(text)
+                    isEntity = FSProvider.isEntity(entity)
+                }
+
+                const properties = getPropertiesEntity(entity)
+                const entities = getRelationsEntityDeeper(entity).relations
+                const suggestions: vscode.ProviderResult<vscode.CompletionItem[] | vscode.CompletionList> = []
+
+                if (properties) {
+                    properties.map(p => {
+                        const item = new vscode.CompletionItem(`${p.name}`)
+                        item.kind = vscode.CompletionItemKind.Field
+                        item.insertText = p.name + ' '
+                        item.detail = `Type: ${p.type}`
+                        suggestions.push(item)
+                    })
+                }
+
+                if (entities) {
+                    entities.map(p => {
+                        const item = new vscode.CompletionItem(p, vscode.CompletionItemKind.Method)
+                        suggestions.push(item)
+                    })
+                }
+
+                return suggestions;
+            }
+
+            return undefined;
+        }
+    },
+    '.'
+);
+
+
+export const CompletionEntityProvider = vscode.languages.registerCompletionItemProvider(
+    'typescript',
+    {
+        provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, context: vscode.CompletionContext) {
+
+            const entities = FSProvider.getAllFileInFolder('/src/entity')
+
+            const suggestions: vscode.ProviderResult<vscode.CompletionItem[] | vscode.CompletionList> = []
+
+            entities.map(e => {
+                const texts = getFullTextType(e)
+                const commitCharacterCompletion = new vscode.CompletionItem(texts.camelCase);
+                commitCharacterCompletion.commitCharacters = ['.'];
+                commitCharacterCompletion.documentation = new vscode.MarkdownString(`Press '.' to get ${texts.camelCase}`);
+                suggestions.push(commitCharacterCompletion)
+            })
+
+            return suggestions.length ? suggestions : undefined
+        }
+    },
+    'ctrl + space'
+);
+
+const TRIGGER_QUERY = [
+    'A', 'B', 'C', 'I', 'L'
+]
+export const CompletionQueryProvider = vscode.languages.registerCompletionItemProvider(
+    { language: 'typescript' },
+    {
+        provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, context: vscode.CompletionContext) {
+            const QUERY_KEYWORDS = [
+                { label: 'AND', insert: 'AND ' },
+                { label: 'IN', insert: ' IN (:...) ' },
+                { label: 'BETWEEN', insert: ' BETWEEN ${} AND ${} ' },
+                { label: 'LIKE', insert: "LIKE '%${search}%' " },
+                { label: 'CONCAT', insert: "CONCAT( ) " },
+                { label: 'IFNULL', insert: "IFNULL( , ) " },
+            ]
+
+
+            const suggestions: vscode.ProviderResult<vscode.CompletionItem[] | vscode.CompletionList> = []
+
+            QUERY_KEYWORDS.map(q => {
+                const item = new vscode.CompletionItem(`${q.label}`)
+                item.kind = vscode.CompletionItemKind.Field
+                item.insertText = q.insert
+                item.detail = q.label
+                suggestions.push(item)
+            })
+
+            return suggestions.length ? suggestions : undefined
+        }
+    },
+    ...TRIGGER_QUERY
+);

package/src/provider/errorChecking/checkHeaderToken.ts

@@ -0,0 +1,60 @@
+import * as vscode from 'vscode';
+import { getParamLinesInFunction, getParams } from './util';
+import { ControllerAction } from '../../constant';
+
+export function getErrorForgetToken(document: vscode.TextDocument) {
+    const lines = getAllUseAuthLine(document)
+    if (!lines || !lines.length) return []
+    const errors = []
+
+    for (const l of lines) {
+        const lineNumber = l.lineNumber
+
+        const paramLines = getParamLinesInFunction(lineNumber, document)
+        const params = paramLines.map(l => getParams(l.text)).filter(Boolean)
+
+        if (!params.some(p => p == 'token')) {
+            let item: vscode.Diagnostic = {
+                code: ControllerAction.AddPathParams,
+                message: `"Params 'token' is required`,
+                range: new vscode.Range(
+                    new vscode.Position(lineNumber, l.firstNonWhitespaceCharacterIndex),
+                    new vscode.Position(lineNumber, l.text.length - 1)
+                ),
+                severity: vscode.DiagnosticSeverity.Error,
+                source: 'typescript',
+                relatedInformation: [
+                    new vscode.DiagnosticRelatedInformation(
+                        new vscode.Location(
+                            document.uri,
+                            new vscode.Range(
+                                new vscode.Position(lineNumber, l.firstNonWhitespaceCharacterIndex),
+                                new vscode.Position(lineNumber, l.text.length - 1)
+                            )
+                        ),
+                        `Param 'token' is required`
+                    )
+                ]
+            }
+            errors.push(item)
+        }
+    }
+
+    return errors
+}
+
+
+function getAllUseAuthLine(document: vscode.TextDocument) {
+    const lines = []
+
+    const totalLine = document.lineCount
+    for (let index = 0; index < totalLine; index++) {
+        const line = document.lineAt(index)
+
+        if (line.text.includes('UseAuth') && line.text.includes('VerificationJWT')) {
+            lines.push(line)
+        }
+    }
+
+    return lines
+}

package/src/provider/errorChecking/checkPathParam.ts

@@ -0,0 +1,64 @@
+import * as vscode from 'vscode';
+import { getParamLinesInFunction, getParams } from './util';
+import { ControllerAction } from '../../constant';
+import { getPathParams, getPath } from '../codeAction/controller/util';
+
+export function getErrorPathParams(document: vscode.TextDocument) {
+    const lines = getAllPathLine(document)
+    if (!lines || !lines.length) return []
+    const errors = []
+
+    for (const l of lines) {
+        const lineNumber = l.lineNumber
+
+        const path = getPath(l.text)
+        const pathParams = getPathParams(path)
+
+        const paramLines = getParamLinesInFunction(lineNumber, document)
+        const params = paramLines.map(l => getParams(l.text)).filter(Boolean)
+
+        let paramMission = pathParams.filter(p => !params.includes(p));
+
+        if (paramMission && paramMission.length) {
+            let item: vscode.Diagnostic = {
+                code: ControllerAction.AddPathParams,
+                message: `"Missing path params: ${paramMission.join(', ')}`,
+                range: new vscode.Range(
+                    new vscode.Position(lineNumber, l.firstNonWhitespaceCharacterIndex),
+                    new vscode.Position(lineNumber, l.text.length - 1)
+                ),
+                severity: vscode.DiagnosticSeverity.Error,
+                source: 'typescript'
+            }
+            errors.push(item)
+        }
+    }
+
+    return errors
+}
+
+
+function getAllPathLine(document: vscode.TextDocument) {
+    const lines = []
+
+    const totalLine = document.lineCount
+    for (let index = 0; index < totalLine; index++) {
+        const line = document.lineAt(index)
+
+        if (isPathLine(line.text)) {
+            lines.push(line)
+        }
+    }
+
+    return lines
+}
+
+function isPathLine(line: string) {
+    return (line.includes('@Get') ||
+        line.includes('@Post') ||
+        line.includes('@Delete') ||
+        line.includes('@Put') ||
+        line.includes('@Patch')) &&
+        line.includes('/:')
+
+}

package/src/provider/errorChecking/checkRequired.ts

@@ -0,0 +1,56 @@
+import * as vscode from 'vscode';
+import { getMatch } from '../../util';
+import { getParamLinesInFunction, getParams, getAllJoiRequireLine } from './util';
+
+export function getErrorValidateRequire(document: vscode.TextDocument) {
+    const lines = getAllJoiRequireLine(document)
+    if (!lines || !lines.length) return []
+
+    const errors = []
+
+    for (const l of lines) {
+        const lineNumber = l.lineNumber
+        const property = getValidateProperty(l.text.trim())
+        if (!property) continue
+
+        const paramLines = getParamLinesInFunction(lineNumber, document)
+        const params = paramLines.map(l => getParams(l.text)).filter(Boolean)
+
+        if (!params.some(p => p == property)) {
+            let item: vscode.Diagnostic = {
+                code: 'required',
+                message: `"${property}" not required`,
+                range: new vscode.Range(
+                    new vscode.Position(lineNumber, l.firstNonWhitespaceCharacterIndex),
+                    new vscode.Position(lineNumber, l.text.length - 1)
+                ),
+                severity: vscode.DiagnosticSeverity.Error,
+                source: 'typescript',
+                relatedInformation: [
+                    new vscode.DiagnosticRelatedInformation(
+                        new vscode.Location(
+                            document.uri,
+                            new vscode.Range(
+                                new vscode.Position(lineNumber, l.firstNonWhitespaceCharacterIndex),
+                                new vscode.Position(lineNumber, l.text.length - 1)
+                            )
+                        ),
+                        `Params: ${params.join(', ')}`
+                    )
+                ]
+            }
+            errors.push(item)
+        }
+    }
+
+    return errors
+}
+
+function getValidateProperty(line: string) {
+    if (line.startsWith('//')) return null
+
+    const matches = getMatch(/\w*:/gm, line)
+    if (!matches || !matches.length) return null
+    else return matches[0].replace(/:/g, '')
+}
+

package/src/provider/errorChecking/errorChecking.ts

@@ -0,0 +1,35 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { Diagnostic } from 'vscode';
+import { getErrorValidateRequire } from './checkRequired';
+import { getErrorForgetToken } from './checkHeaderToken';
+import { getErrorPathParams } from './checkPathParam';
+
+export function updateDiagnostics(
+    document: vscode.TextDocument,
+    collection: vscode.DiagnosticCollection
+): void {
+    if (isControllerFile(document)) {
+        const errors = getErrorChecking(document)
+        if (!errors || !errors.length) collection.clear();
+
+        collection.set(document.uri, errors)
+    } else {
+        collection.clear();
+    }
+}
+
+function getErrorChecking(document: vscode.TextDocument) {
+    const errors: Diagnostic[] = []
+
+    errors.push(...getErrorValidateRequire(document))
+    errors.push(...getErrorForgetToken(document))
+    errors.push(...getErrorPathParams(document))
+
+    return errors
+}
+
+
+function isControllerFile(document: vscode.TextDocument) {
+    return document && path.basename(document.uri.fsPath).includes('Controller')
+}

package/src/provider/errorChecking/util.ts

@@ -0,0 +1,56 @@
+import * as vscode from 'vscode';
+import { getMatch } from '../../util';
+
+export function getParamLinesInFunction(lineNumber: number, document: vscode.TextDocument) {
+    const lines = []
+
+    const totalLine = document.lineCount
+    for (let index = lineNumber; index < totalLine; index++) {
+        const line = document.lineAt(index)
+
+        const text = line.text.trim()
+
+        if (
+            text.includes('@') &&
+            !text.includes('UseAuth') &&
+            !text.includes('Validator') &&
+            !text.includes('Validator') &&
+            !text.includes('@Req') &&
+            !text.includes('@Res') &&
+            !text.includes('@Get') &&
+            !text.includes('@Post') &&
+            !text.includes('@Delete') &&
+            !text.includes('@Put') &&
+            !text.includes('@Patch') &&
+            !text.startsWith('//')
+        ) {
+            lines.push(line)
+        }
+
+        if (text.includes(') {') || text.includes('){')) break
+    }
+
+    return lines
+}
+
+export function getParams(line: string) {
+    const matches = getMatch(/"\w*"|'\w*'/gm, line)
+    if (!matches || !matches.length) return null
+    else return matches[0].replace(/"/g, '').replace(/'/g, '')
+}
+
+
+export function getAllJoiRequireLine(document: vscode.TextDocument) {
+    const lines = []
+
+    const totalLine = document.lineCount
+    for (let index = 0; index < totalLine; index++) {
+        const line = document.lineAt(index)
+
+        if (line.text.includes('Joi') && line.text.includes('require')) {
+            lines.push(line)
+        }
+    }
+
+    return lines
+}

package/src/provider/treeDataProvider/Dependency.ts

@@ -0,0 +1,26 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+
+export class Dependency extends vscode.TreeItem {
+    constructor(
+        public readonly label: string,
+        public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+        public readonly command?: vscode.Command,
+        public readonly context?: string,
+        public readonly icon?: string,
+    ) {
+        super(label, collapsibleState)
+    }
+
+    // get tooltip(): string {
+    //     return `${this.label}`;
+    // }
+
+    iconPath = {
+        light: path.join(__filename, '..', '..', '..', '..', 'media', 'light', `${this.icon}.svg`),
+        dark: path.join(__filename, '..', '..', '..', '..', 'media', 'dark', `${this.icon}.svg`)
+    };
+
+    contextValue = this.context;
+
+}