bmd-extension 1.6.3

package/src/provider/codeAction/entity/codeAction.ts

@@ -0,0 +1,48 @@
+import * as vscode from 'vscode';
+import { createPropertyAction } from './handleProperty';
+import { createRelationAction } from './handleRelation';
+import { createBuilderAction } from './handleBuilder';
+import { createAddRelationFunctionAction, createAddFunctionAction } from './handleFunction';
+
+
+export class EntityActionProvider implements vscode.CodeActionProvider {
+
+    public static readonly providedCodeActionKinds = [
+        vscode.CodeActionKind.QuickFix
+    ];
+
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        range: any
+    ): vscode.CodeAction[] | undefined | any {
+        // Add properties to entity file
+        const addPropertiesAction = createPropertyAction(document, range)
+        if (addPropertiesAction && addPropertiesAction.length)
+            return addPropertiesAction
+
+        // // Add relation to entity file
+        // const addRelationAction = createRelationAction(document, range)
+        // if (addRelationAction && addRelationAction.length)
+        //     return addRelationAction
+
+        // Add relation to entity function like: find, findOne
+        const addFunctionAction = createAddFunctionAction(document, range)
+        if (addFunctionAction && addFunctionAction.length)
+            return addFunctionAction
+
+        // Add relation to query builder
+        const addBuilderRelationAction = createBuilderAction(document, range)
+        if (addBuilderRelationAction && addBuilderRelationAction.length)
+            return addBuilderRelationAction
+
+
+        // Add relation to entity function like: find, findOne
+        const addRelationFunctionAction = createAddRelationFunctionAction(document, range)
+        if (addRelationFunctionAction && addRelationFunctionAction.length)
+            return addRelationFunctionAction
+
+        return []
+    }
+
+}
+

package/src/provider/codeAction/entity/handleBuilder.ts

@@ -0,0 +1,87 @@
+import * as vscode from 'vscode';
+import { EntityAction } from '../../../constant';
+import { getEntityFromFunction, getRelationsEntity, findLastLineRelation } from './helper';
+import { getFullTextType } from '../../../util';
+
+export function createBuilderAction(
+    document: vscode.TextDocument, range: vscode.Range
+) {
+    if (isQueryBuilder(document, range)) {
+        const insertBuilderRelation = createInsertBuilderRelation(document, range);
+
+        return [
+            insertBuilderRelation,
+        ];
+    }
+
+    return []
+}
+
+function isQueryBuilder(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+    return line.text.includes('createQueryBuilder')
+}
+
+
+function createInsertBuilderRelation(
+    document: vscode.TextDocument, range: vscode.Range
+): vscode.CodeAction {
+    const entity = new vscode.CodeAction(EntityAction.AddBuilderRelation, vscode.CodeActionKind.QuickFix);
+
+    entity.command = {
+        command: EntityAction.AddBuilderRelation,
+        title: 'Add builder relation: ',
+        tooltip: 'Add builder relation: ',
+        arguments: [document, range]
+    };
+
+    return entity;
+}
+
+
+export async function insertBuilderRelation(typeFunc: EntityAction, document: vscode.TextDocument, range: vscode.Range) {
+    const edit = new vscode.WorkspaceEdit();
+
+    const entityObj = getEntityFromFunction(document, range)
+    const entity = entityObj.text
+
+    if (!entity) return vscode.window.showInformationMessage('Can not get entity')
+
+    const relations = getRelationsEntity(entity)
+    if (!relations.length) return vscode.window.showInformationMessage('Not exist any relation')
+
+    const relation = await vscode.window.showQuickPick(
+        relations,
+        { ignoreFocusOut: true })
+    if (!relation) return
+
+    let first = ''
+    let second = ''
+
+    if (!relation.includes('.')) {
+        first = `${getFullTextType(entity).camelCase}.${relation}`
+        second = `${relation}`
+    } else {
+        first = `${relation}`
+        const words = first.split('.')
+        second = `${words[1]}`
+    }
+
+    const fullText = getFullTextType(entity)
+
+    let template = `.leftJoinAndSelect('{{first}}', '{{second}}')
+    `
+    template = template.replace(/{{first}}/g, first);
+    template = template.replace(/{{second}}/g, second);
+
+    const start = range.start;
+    const line = document.lineAt(start.line)
+    console.log('line:', line)
+    const lastRelation = findLastLineRelation(document, line)
+    console.log('lastRelation:', lastRelation)
+
+    edit.insert(document.uri, new vscode.Position(lastRelation, 12), template);
+
+    vscode.workspace.applyEdit(edit)
+}

package/src/provider/codeAction/entity/handleFunction.ts

@@ -0,0 +1,487 @@
+import * as vscode from 'vscode';
+import { EntityAction } from '../../../constant';
+import { FSProvider } from '../../../FsProvider';
+import { getEntityFromFunction, getRelationsEntity } from './helper';
+import { getFullTextType } from '../../../util';
+import { Uri, commands } from 'vscode';
+
+export function createAddRelationFunctionAction(
+    document: vscode.TextDocument, range: vscode.Range
+) {
+    if (isEntityFunction(document, range)) {
+
+        const insertRelation = insertRelations(document, range)
+
+        return [
+            insertRelation
+        ];
+    }
+    return []
+}
+
+function isEntityFunction(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+    return line.text.includes('find')
+}
+
+function isQueryString(document: vscode.TextDocument, range: vscode.Range) {
+    return true
+
+}
+
+function insertRelations(
+    document: vscode.TextDocument,
+    range: vscode.Range
+): vscode.CodeAction {
+    const entity = new vscode.CodeAction(EntityAction.AddRelation, vscode.CodeActionKind.QuickFix);
+
+    entity.command = {
+        command: EntityAction.AddRelation,
+        title: 'Add relation: ',
+        tooltip: 'Add relation: ',
+        arguments: [document, range]
+    };
+
+    return entity;
+}
+
+export async function insertEntityFunction(typeFunc: EntityAction, document: vscode.TextDocument, range: vscode.Range) {
+    const edit = new vscode.WorkspaceEdit();
+
+    const entityObj = getEntityFromFunction(document, range)
+    const entity = entityObj.text
+
+    if (!entity) return vscode.window.showInformationMessage('Can not get entity')
+
+    const relations = getRelationsEntity(entity)
+    if (!relations.length) return vscode.window.showInformationMessage('Not exist any relation')
+
+    const { allLine, mapLines } = getAllFunctionLine(document, range)
+
+    if (allLine.includes('relations')) {
+        const relationSelected = getRelationSelected(mapLines)
+        const relationNotSelected = relations.filter((item: string) => {
+            if (!relationSelected.includes(item)) return item
+        })
+
+        if (!relationNotSelected.length) return vscode.window.showInformationMessage('All relation was selected')
+
+        const relation = await vscode.window.showQuickPick(relationNotSelected, { ignoreFocusOut: true })
+        if (!relation) return
+
+        const { template, position } = handleExistRelation(relation, mapLines)
+        if (!position) return vscode.window.showInformationMessage('Can not find position to insert')
+
+        edit.insert(document.uri, position, template)
+    } else {
+        const relation = await vscode.window.showQuickPick(relations, { ignoreFocusOut: true })
+        if (!relation) return vscode.window.showInformationMessage('Please select relation')
+
+        const { template, position } = handleNotExistRelation(relation, mapLines)
+        if (!position) return vscode.window.showInformationMessage('Can not find position to insert')
+
+        edit.insert(document.uri, position, template);
+    }
+
+    vscode.workspace.applyEdit(edit)
+}
+
+function getAllFunctionLine(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line).text
+    console.log('line:', line)
+    let allLine = line
+    console.log('allLine:', allLine)
+    let mapLines = new Map()
+
+    mapLines.set(start.line, line)
+    if (line.match(/(\(\W*[a-zA-z]+\))|(\(\))|(\))/g) || line.includes('})')) {
+        return { allLine, mapLines }
+    }
+
+    const isContinue = true
+    let currentLine = start.line
+    while (isContinue) {
+        const nextLine = document.lineAt(currentLine + 1).text
+        allLine += nextLine
+        mapLines.set(currentLine + 1, nextLine)
+        if (nextLine.includes(')')) {
+            return { allLine, mapLines }
+        }
+        currentLine += 1
+    }
+
+    return { allLine, mapLines }
+}
+
+function getRelationSelected(mapLines: Map<number, string>) {
+    for (const [lineNumber, value] of mapLines.entries()) {
+        const matchRelations = value.match(/relations:.*\[/)
+
+        if (matchRelations) {
+            const matchRelationsProps = value.match(/('\w*'|'\w*\.\w*')/g)
+
+            if (!matchRelationsProps) return []
+            return matchRelationsProps.map(prop => prop.replace(/'/g, ''))
+        }
+    }
+    return []
+}
+
+function handleExistRelation(relation: string, mapLines: Map<number, string>): any {
+    let template = `'${relation}', `
+    let indexOf = 0
+
+    for (const [lineNumber, value] of mapLines.entries()) {
+        const matchRelations = value.match(/relations:.*\[/)
+        if (matchRelations) {
+            const matched = matchRelations[0]
+            indexOf = value.indexOf(matched) != -1 ? value.indexOf(matched) + matched.length : 0
+            return { template, position: new vscode.Position(lineNumber, indexOf) }
+        }
+    }
+}
+
+function handleNotExistRelation(relation: string, mapLines: Map<number, string>): { template: string, position: vscode.Position | null } {
+    let template = ``
+    let indexOf = 0
+    const [firstKey, firstValue] = mapLines.entries().next().value
+
+    const matchBracket = firstValue.match(/(\(\W*[a-zA-Z-_]+,\s{)|(\({)/)
+    if (matchBracket?.length) {
+        const matched = matchBracket[0]
+        template = `\nrelations: ['${relation}'],`
+        indexOf = firstValue.indexOf(matched) != -1 ? firstValue.indexOf(matched) + matched.length : 0
+        return { template, position: new vscode.Position(firstKey, indexOf) }
+    }
+
+    const matchNoBracket = firstValue.match(/\(\W*[a-zA-Z_-\W][^\)]+|(\()/)
+
+    if (matchNoBracket?.length) {
+        const matched = matchNoBracket[0]
+        template = `{\nrelations: ['${relation}']\n}`
+        if (matched.match(/[a-zA-Z]/)) {
+            template = `, {\nrelations: ['${relation}']\n}`
+        }
+        indexOf = firstValue.indexOf(matched) != -1 ? firstValue.indexOf(matched) + matched.length : 0
+        return { template, position: new vscode.Position(firstKey, indexOf) }
+    }
+
+    return { template, position: null }
+}
+
+
+export function createAddFunctionAction(
+    document: vscode.TextDocument, range: vscode.Range
+) {
+    if (isEntityClassNotBuilder(document, range)) {
+
+        const insertQueryBuilderPagination = createEntityFunction(document, range, EntityAction.CreateQueryBuilderPagination);
+        const insertQueryBuilderFindAll = createEntityFunction(document, range, EntityAction.CreateQueryBuilderFindAll);
+        const insertQueryBuilderFindOne = createEntityFunction(document, range, EntityAction.CreateQueryBuilderFindOne);
+        const insertFindOneID = createEntityFunction(document, range, EntityAction.FindOneOrThrowID);
+
+        return [
+            insertFindOneID,
+            insertQueryBuilderPagination,
+            insertQueryBuilderFindAll,
+            insertQueryBuilderFindOne,
+        ];
+    }
+
+    return []
+}
+
+function isEntityClassNotBuilder(document: vscode.TextDocument, range: vscode.Range) {
+    const entities = FSProvider.getAllFileInFolder('/src/entity')
+
+    const start = range.start;
+    const line = document.lineAt(start.line);
+
+    let isIncludesEntity = false
+    entities.map((entity: string) => {
+        if (line.text.includes(entity)) {
+            isIncludesEntity = true
+        }
+    })
+    return isIncludesEntity &&
+        !line.text.includes('Controller') &&
+        !line.text.includes('Service') &&
+        !line.text.includes('createQueryBuilder') &&
+        !line.text.includes('find')
+}
+
+
+export async function handleOpenAndScrollToRelation(document: vscode.TextDocument, range: vscode.Range) {
+    const edit = new vscode.WorkspaceEdit();
+    const entityObj = getEntityFromFunction(document, range)
+    const entity = entityObj.text
+
+    if (!entity) return vscode.window.showInformationMessage('Can not get entity')
+
+    // const activeEditor1 = vscode.window.activeTextEditor;
+    // console.log('activeEditor 1:', activeEditor1)
+
+
+    const distPath = `src/entity/${entity}.ts`
+    let uri = Uri.file(FSProvider.getFullPath(distPath))
+
+    await commands.executeCommand('vscode.openFolder', uri)
+
+    const newDocument = vscode.window.activeTextEditor?.document
+    if (!newDocument) return vscode.window.showInformationMessage('Can not get new file open')
+
+    const positionRelation = getRelationsCommentLine(distPath)
+    console.log('positionRelation:', positionRelation)
+
+    await commands.executeCommand('moveActiveEditor', { to: 'last', by: 'tab' })
+
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) return
+    const position = editor?.selection.active;
+    console.log('position:', position)
+    editor.selections = [new vscode.Selection(new vscode.Position(0, 0), new vscode.Position(0, 0))]
+
+    const result = await commands.executeCommand('cursorMove', { to: 'up', value: position.line })
+    console.log('result:', result)
+    // await commands.executeCommand('editorScroll', { to: 'down', by: 'line', value: positionRelation })
+
+}
+
+function getRelationsCommentLine(path: string) {
+    const lines = FSProvider.getLinesDocumentInFile(path)
+    let position = 0
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index]
+        if (line.includes('RELATIONS')) position = index
+    }
+    return position
+}
+
+function createEntityFunction(document: vscode.TextDocument, range: vscode.Range, typeFunc: EntityAction): vscode.CodeAction {
+    const entity = new vscode.CodeAction(typeFunc, vscode.CodeActionKind.QuickFix);
+    switch (typeFunc) {
+
+        case EntityAction.CreateQueryBuilderPagination:
+            entity.command = {
+                command: typeFunc,
+                title: 'Create query build pagination: ',
+                tooltip: 'Create query build pagination: ',
+                arguments: [document, range]
+            };
+            break
+
+        case EntityAction.CreateQueryBuilderFindAll:
+            entity.command = {
+                command: typeFunc,
+                title: 'Create query build find all: ',
+                tooltip: 'Create query build find all: ',
+                arguments: [document, range]
+            };
+            break
+
+        case EntityAction.CreateQueryBuilderFindOne:
+            entity.command = {
+                command: typeFunc,
+                title: 'Create query build find one: ',
+                tooltip: 'Create query build find one: ',
+                arguments: [document, range]
+            };
+            break
+
+        case EntityAction.CreateQueryBuilderFindAll:
+            entity.command = {
+                command: typeFunc,
+                title: 'Create query build find all: ',
+                tooltip: 'Create query build find all: ',
+                arguments: [document, range]
+            };
+            break
+
+        case EntityAction.CreateQueryBuilderFindOne:
+            entity.command = {
+                command: typeFunc,
+                title: 'Create query build find one: ',
+                tooltip: 'Create query build find one: ',
+                arguments: [document, range]
+            };
+            break
+
+        case EntityAction.FindOneOrThrowID:
+            entity.command = {
+                command: typeFunc,
+                title: 'Find one or throw ID: ',
+                tooltip: 'Find one or throw ID: ',
+                arguments: [document, range]
+            };
+            break
+
+        case EntityAction.AddBuilderRelation:
+            entity.command = {
+                command: typeFunc,
+                title: 'Add builder relation: ',
+                tooltip: 'Add builder relation: ',
+                arguments: [document, range]
+            };
+            break
+
+
+        default:
+            break;
+
+    }
+
+    return entity;
+}
+
+export async function insertQueryBuilder(typeFunc: EntityAction, document: vscode.TextDocument, range: vscode.Range) {
+    const edit = new vscode.WorkspaceEdit();
+
+    const entityObj = getEntityFromFunction(document, range)
+    const entity = entityObj.text
+
+    if (!entity) return vscode.window.showInformationMessage('Can not get entity')
+
+    const fullText = getFullTextType(entity)
+
+    let template = getTemplateQueryBuilder(typeFunc)
+    let where = getWhereQueryBuilder(typeFunc)
+
+    template = template.replace(/{{camel}}/g, fullText.camelCase);
+    template = template.replace(/{{cap}}/g, fullText.classifyCase);
+    template = template.replace(/{{dollar}}/g, '$');
+    template = template.replace(/{{backtick}}/g, '`');
+
+    where = where.replace(/{{camel}}/g, fullText.camelCase);
+    where = where.replace(/{{cap}}/g, fullText.classifyCase);
+    where = where.replace(/{{dollar}}/g, '$');
+    where = where.replace(/{{backtick}}/g, '`');
+
+    const start = range.start;
+    const line = document.lineAt(start.line)
+    const preLine = document.lineAt(line.lineNumber - 1)
+    const preLineLastIndex = preLine.text
+
+    edit.insert(document.uri, new vscode.Position(line.lineNumber, line.text.length + 1), template);
+    edit.insert(document.uri, new vscode.Position(preLine.lineNumber, preLineLastIndex.length), where)
+    vscode.workspace.applyEdit(edit)
+}
+
+function getWhereQueryBuilder(typeFunc: EntityAction) {
+    let template = ``
+
+    switch (typeFunc) {
+        case EntityAction.CreateQueryBuilderPagination:
+            template = `\n\t\tlet where = {{backtick}}{{camel}}.name LIKE '%{{dollar}}{search}%' AND {{camel}}.isDeleted = false{{backtick}}`
+            break;
+
+        case EntityAction.CreateQueryBuilderFindAll:
+            template = `\n\t\tlet where = {{backtick}}{{camel}}.isDeleted = false{{backtick}}`
+            break;
+
+        case EntityAction.CreateQueryBuilderFindOne:
+            template = `\n\t\tlet where = {{backtick}}{{camel}}.isDeleted = false{{backtick}}`
+            break;
+
+    }
+
+    return template
+}
+
+function getTemplateQueryBuilder(typeFunc: EntityAction) {
+    let template = ``
+
+    switch (typeFunc) {
+        case EntityAction.CreateQueryBuilderPagination:
+            template = `.createQueryBuilder('{{camel}}')
+            .where(where)
+            .skip((page - 1) * limit)
+            .take(limit)
+            .orderBy('{{camel}}.id', 'DESC')
+            .getManyAndCount()
+    `
+            break;
+
+        case EntityAction.CreateQueryBuilderFindAll:
+            template = `.createQueryBuilder('{{camel}}')
+            .where(where)
+            .orderBy('{{camel}}.id', 'DESC')
+            .getMany()
+    `
+            break;
+
+        case EntityAction.CreateQueryBuilderFindOne:
+            template = `.createQueryBuilder('{{camel}}')
+            .where(where)
+            .getOne()
+    `
+            break;
+
+    }
+
+    return template
+}
+
+
+export async function insertFindOneOrThrow(typeFunc: EntityAction, document: vscode.TextDocument, range: vscode.Range) {
+    const edit = new vscode.WorkspaceEdit();
+
+    const entityObj = getEntityFromFunction(document, range)
+    const entity = entityObj.text
+
+    if (!entity) return vscode.window.showInformationMessage('Can not get entity')
+
+    const fullText = getFullTextType(entity)
+
+    let template = `.findOneOrThrowId({{camel}}Id, null, '')
+    `
+    template = template.replace(/{{camel}}/g, fullText.camelCase);
+    template = template.replace(/{{cap}}/g, fullText.classifyCase);
+    template = template.replace(/{{dollar}}/g, '$');
+    template = template.replace(/{{backtick}}/g, '`');
+
+    const start = range.start;
+    const line = document.lineAt(start.line)
+
+    edit.insert(document.uri, new vscode.Position(line.lineNumber, line.text.length + 1), template);
+
+    vscode.workspace.applyEdit(edit)
+}
+
+
+export function createGetPropertiesAction(
+    document: vscode.TextDocument, range: vscode.Range
+) {
+    if (isEntityFunction(document, range)) {
+        const insertRelation = insertRelations(document, range)
+
+        return [
+            insertRelation
+        ];
+    }
+    return []
+}
+
+export async function insertPropertiesToQuery(
+    document: vscode.TextDocument,
+    range: vscode.Range,
+    lastIndex: number,
+    property: string
+) {
+    const edit = new vscode.WorkspaceEdit();
+
+    const entityObj = getEntityFromFunction(document, range, true)
+    const entity = entityObj.text
+
+    if (!entity) return vscode.window.showInformationMessage('Can not get entity')
+
+    const fullText = getFullTextType(entity)
+
+    const start = range.start;
+    const line = document.lineAt(start.line)
+
+    edit.insert(document.uri, new vscode.Position(line.lineNumber, lastIndex + 1), `.${property}`);
+
+    vscode.workspace.applyEdit(edit)
+}

package/src/provider/codeAction/entity/handleProperty.ts

@@ -0,0 +1,32 @@
+import * as vscode from 'vscode';
+import { EntityAction } from '../../../constant';
+
+export function createPropertyAction(document: vscode.TextDocument, range: vscode.Range) {
+    if (isEntityProperties(document, range)) {
+        const addProperty = createAddPropertyAction(document, range)
+
+        return [addProperty];
+    }
+
+    return []
+}
+
+function createAddPropertyAction(document: vscode.TextDocument, range: vscode.Range): vscode.CodeAction {
+    const entity = new vscode.CodeAction(EntityAction.AddProperty, vscode.CodeActionKind.QuickFix);
+
+    entity.command = {
+        command: EntityAction.AddProperty,
+        title: 'Add property: ',
+        tooltip: 'Add property: ',
+        arguments: [document]
+    };
+
+    return entity;
+}
+
+function isEntityProperties(document: vscode.TextDocument, range: vscode.Range) {
+    const start = range.start;
+    const line = document.lineAt(start.line);
+    return line.text.includes('PROPERTIES') && document.fileName.includes('entity/')
+}
+