m

dist/gen/define_config.d.ts

@@ -0,0 +1,20 @@
+import { Type } from '@nestjs/common';
+import { BaseModel } from 'src/model/_base_model';
+export interface GeneratedConfig<T extends BaseModel = any> {
+    [model: string]: {
+        identity?: Type<T>;
+        api?: {
+            query?: Type<T>[];
+            create?: Type<T>[];
+            delete?: Type<T>[];
+            update?: Type<T>[];
+        };
+        public?: {
+            query?: Type<T>[];
+            create?: Type<T>[];
+            delete?: Type<T>[];
+            update?: Type<T>[];
+        };
+    };
+}
+export declare const defineGeneratedConfig: (opt: GeneratedConfig) => GeneratedConfig<any>;

dist/gen/define_config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineGeneratedConfig = void 0;
+const defineGeneratedConfig = (opt) => {
+    return opt;
+};
+exports.defineGeneratedConfig = defineGeneratedConfig;
+//# sourceMappingURL=define_config.js.map

dist/gen/define_config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define_config.js","sourceRoot":"","sources":["../../src/gen/define_config.ts"],"names":[],"mappings":";;;AAwBO,MAAM,qBAAqB,GAAG,CAAC,GAAoB,EAAE,EAAE;IAC5D,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAFW,QAAA,qBAAqB,yBAEhC"}

dist/gen/gen.js

@@ -0,0 +1 @@
+//# sourceMappingURL=gen.js.map

dist/gen/gen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen.js","sourceRoot":"","sources":["../../src/gen/gen.ts"],"names":[],"mappings":""}

dist/gen/generated.d.ts

@@ -0,0 +1 @@
+export {};

dist/gen/generated.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = require("glob");
+const path_1 = require("path");
+const orm_config_1 = require("../config/orm.config");
+const fs_1 = require("fs");
+const handlebars_1 = require("handlebars");
+const mode = process.env.GEN_MODE;
+const GENERATED_DIR = (0, path_1.join)(__dirname, '../generated', mode);
+const generated_config_1 = require("../config/generated.config");
+const generatedConfig = generated_config_1.default[mode] || {};
+if (!(0, fs_1.existsSync)(GENERATED_DIR)) {
+    (0, fs_1.mkdirSync)(GENERATED_DIR);
+}
+const findTargetByConfigExist = (target, types, def = true) => {
+    if ((typeof types == 'undefined' && !types) || !types.length) {
+        return def;
+    }
+    return types.includes(target);
+};
+async function generated() {
+    const indexTemplate = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, './index.handlebars')).toString();
+    const controllerTemplate = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, './controller.handlebars')).toString();
+    const controllerCompiled = handlebars_1.default.compile(controllerTemplate);
+    const indexrCompiled = handlebars_1.default.compile(indexTemplate);
+    await orm_config_1.default.initialize();
+    const p = (0, path_1.join)(__dirname, '../model/**/*.model.{j,t}s');
+    const files = glob_1.glob.sync(p);
+    const configs = {};
+    files.forEach((file) => {
+        const modelRelativePath = (0, path_1.relative)(GENERATED_DIR, file).replace('.ts', '');
+        const modelFullName = (0, path_1.basename)(modelRelativePath);
+        const modelName = modelFullName.split('.')[0];
+        const modelTableName = modelName + '_model';
+        const controllerPath = 'generated/' + modelName;
+        const controlleName = modelName.replace(/(^\w)/, (c) => c.toUpperCase());
+        configs[modelTableName] = {
+            modelName,
+            modelFullName,
+            modelTableName,
+            controllerPath,
+            controlleName,
+            modelRelativePath,
+        };
+    });
+    const identity = orm_config_1.default.manager.connection.entityMetadatas.find((it) => it.target == generatedConfig.identity);
+    const identityProperty = identity?.generatedColumns?.map((it) => it.propertyName)[0];
+    const identityPropertyPrefix = identity?.tableName?.split('_')[0];
+    const controllers = orm_config_1.default.manager.connection.entityMetadatas.map((metadata) => {
+        const name = metadata.name;
+        const apiTags = metadata.comment || name;
+        const modelName = metadata.targetName
+            .replace(/^[A-Z]/, (match) => match.toLowerCase())
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase();
+        const config = configs[modelName];
+        const relations = metadata.relations.map((it) => it.propertyName);
+        const queryApi = findTargetByConfigExist(metadata.target, generatedConfig?.api?.query);
+        const createApi = findTargetByConfigExist(metadata.target, generatedConfig?.api?.create);
+        const updateApi = findTargetByConfigExist(metadata.target, generatedConfig?.api?.update);
+        const deleteApi = findTargetByConfigExist(metadata.target, generatedConfig?.api?.delete);
+        const queryPublic = findTargetByConfigExist(metadata.target, generatedConfig?.public?.query, false);
+        const createPublic = findTargetByConfigExist(metadata.target, generatedConfig?.public?.create, false);
+        const updatePublic = findTargetByConfigExist(metadata.target, generatedConfig?.public?.update, false);
+        const deletePublic = findTargetByConfigExist(metadata.target, generatedConfig?.public?.delete, false);
+        let identity = '';
+        const isSelf = metadata.target == generatedConfig.identity;
+        if (identityProperty) {
+            identity = isSelf
+                ? identityProperty
+                : identityPropertyPrefix +
+                    identityProperty.replace(/(^\w)/, (c) => c.toUpperCase());
+        }
+        const findDtoPropertys = metadata.columns
+            .filter((it) => {
+            if (!it.target) {
+                return false;
+            }
+            if (identity && !isSelf && it.propertyName == identity) {
+                return false;
+            }
+            return true;
+        })
+            .map((it) => {
+            const swagger = Reflect.getMetadata('swagger/apiModelProperties', it.target.prototype, it.propertyName);
+            let type = Reflect.getMetadata('design:type', it.target.prototype, it.propertyName).name.toLocaleLowerCase();
+            if (type == 'array' ||
+                type == 'i18nstring' ||
+                type == 'boleplayercostinfo') {
+                type = 'string';
+            }
+            return {
+                comment: swagger?.description || it.comment,
+                property: it.propertyName,
+                type: type,
+            };
+        });
+        const identityExist = metadata.columns.findIndex((it) => it.propertyName == identity) > -1;
+        const tplVars = {
+            apiTags,
+            queryApi,
+            createApi,
+            updateApi,
+            deleteApi,
+            queryPublic,
+            createPublic,
+            updatePublic,
+            deletePublic,
+            identity,
+            isSelf,
+            identityExist,
+            modelName: config.modelName,
+            controlleName: config.controlleName,
+            modelNameDto: name,
+            findDtoPropertys,
+            relations,
+            modelImport: new handlebars_1.default.SafeString(`import { ${name} } from '${config.modelRelativePath}';`),
+        };
+        const content = controllerCompiled(tplVars);
+        const controller = (0, path_1.join)(GENERATED_DIR, config.controllerPath.replace('/', '_') + '.controller.ts');
+        (0, fs_1.writeFileSync)(controller, content);
+        return {
+            name: `Generated${config.controlleName}Controller`,
+            modelImport: new handlebars_1.default.SafeString(`import { Generated${config.controlleName}Controller } from './${(0, path_1.relative)(GENERATED_DIR, controller).replace('.ts', '')}';`),
+        };
+    });
+    const indexFile = (0, path_1.join)(GENERATED_DIR, 'index.ts');
+    const content = indexrCompiled({ controllers });
+    (0, fs_1.writeFileSync)(indexFile, content);
+    await orm_config_1.default.destroy();
+}
+void generated();
+//# sourceMappingURL=generated.js.map