@egi/smart-db 2.3.1 → 2.3.2

package/src/helpers/extract-db-api.ts

@@ -0,0 +1,465 @@
+import fs from "fs";
+import _ from "lodash";
+
+import process from "process";
+import {SmartDbBetterSqlite3} from "../drivers/smart-db-better-sqlite3";
+
+import {SmartDbCoreTableModel} from "../models/smart-db-core-table-model";
+import {SqliteMasterModel} from "../models/sqlite-master-model";
+import {SmartDb} from "../smart-db";
+import {IN, NE} from "../smart-db-globals";
+import {AttributeInfo} from "../smart-db-interfaces";
+
+interface AnalysisAttributeInfo extends AttributeInfo {
+    name: string;
+    attribute: string;
+}
+
+interface ExtractOptions {
+    db: SmartDb;
+    modelDirectory: string;
+    smartDbInterfaces: string;
+    abstractModelModule: string;
+    includeCoreTables?: boolean;
+}
+
+// noinspection NestedFunctionJS
+function getType(rowType: string): string {
+    let type: string;
+
+    if (rowType) {
+        if (rowType.match(/varchar/i) || rowType.match(/text/i)) {
+            type = "string";
+        } else if (rowType.match(/integer\(1\)/i)) {
+            type = "boolean";
+        } else if (rowType.match(/date/i)) {
+            type = "Date";
+        } else if (rowType.match(/integer/i) || rowType.match(/number/i)) {
+            type = "number";
+        } else if (rowType) {
+            type = rowType;
+        } else {
+            type = "SqlValueType";
+        }
+    } else {
+        type = "SqlValueType";
+    }
+
+    return type;
+}
+
+function extractDbApi(options: ExtractOptions) {
+    console.log(`extract interface from '${options.db.getDbConnector()}' to '${options.modelDirectory}'`);
+
+    if (!fs.existsSync(options.modelDirectory)) {
+        fs.mkdirSync(options.modelDirectory, {
+            recursive: true
+        });
+    }
+
+    const relations: (SqliteMasterModel[] | false) = options.db.getAllSync(SqliteMasterModel, {
+        type: IN(["table", "view"]),
+        name: NE("sqlite_sequence")
+    });
+
+    if (relations === false) {
+        console.error(options.db.getLastError());
+        process.abort();
+    } else {
+        let coreTables: string[] = [];
+        if (!options.includeCoreTables && options.db.existsSync(SmartDbCoreTableModel)) {
+            const coreTableRows = options.db.getAllSync(SmartDbCoreTableModel);
+            if (coreTableRows === false) {
+                throw options.db.getLastError();
+            } else {
+                coreTableRows.forEach((row) => {
+                    coreTables.push(row.name);
+                });
+            }
+        }
+
+        const dictionaryRelations: string[] = [];
+        relations.forEach((relation) => {
+            if (!coreTables.includes(relation.name)) {
+                const className = relation.name[0].toUpperCase() + _.camelCase(relation.name.substr(1)) + "Model";
+                dictionaryRelations.push(className);
+
+                const fieldsInfos: AnalysisAttributeInfo[] = [];
+
+                options.db.getTableInfo(relation.name).then((info) => {
+                    const fields = info.fields;
+
+                    let hasSqlValueType = false;
+                    let data = "";
+                    let header = "/* eslint-disable @typescript-eslint/member-ordering */\n";
+                    header += "// noinspection JSUnusedGlobalSymbols\n\n";
+
+                    if (fields) {
+                        header += `import {AbstractModel, GenericModelData, ModelAttributeMap} from "${options.abstractModelModule}";\n`;
+
+                        data += `export interface ${className}Data extends GenericModelData {\n`;
+
+                        if (relation.name == "user") {
+                            fields.push({
+                                name: "hash",
+                                type: "string",
+                                virtual: true
+                            }, {
+                                name: "privileges",
+                                type: "string[]",
+                                virtual: true
+                            });
+                        }
+
+                        let pkName = "";
+                        let fieldPrefix = "";
+                        let prefixRegex: RegExp;
+                        let hasColumnWithoutPrefix = false;
+                        const prefixes: string[] = [];
+                        fields.forEach((field) => {
+                            const prefixMatch = field.name.match(/([a-z0-9]{1,4})_/i);
+
+                            if (field.isPk) {
+                                pkName = field.name as string;
+                                if (prefixMatch) {
+                                    fieldPrefix = prefixMatch[1];
+                                }
+                            }
+
+                            if (prefixMatch) {
+                                if (!prefixes.includes(prefixMatch[1])) {
+                                    prefixes.push(prefixMatch[1]);
+                                }
+                            } else {
+                                hasColumnWithoutPrefix = true;
+                            }
+
+                        });
+
+                        if (!fieldPrefix && !hasColumnWithoutPrefix && prefixes.length == 1) {
+                            fieldPrefix = prefixes[0];
+                        }
+
+                        if (fieldPrefix) {
+                            prefixRegex = new RegExp(`^${fieldPrefix}_(.*)$`);
+                        }
+
+                        const attributes: Record<string, string> = {};
+
+                        fields.forEach((row) => {
+                            const type = getType(row.type);
+                            if (!hasSqlValueType && type == "SqlValueType") {
+                                header += `import {SqlValueType} from "${options.smartDbInterfaces}";\n`;
+                                hasSqlValueType = true;
+                            }
+
+                            let attribute: string;
+
+                            const prefixMatch = prefixRegex && row.name.match(prefixRegex);
+                            if (prefixMatch) {
+                                attribute = _.camelCase(prefixMatch[1]);
+                            } else {
+                                attribute = _.camelCase(row.name);
+                            }
+
+                            let typeScriptStyle = true;
+
+                            if (false && row.name == pkName && _.camelCase(row.name) != row.name) {
+                                fieldsInfos.push({
+                                    name: _.camelCase(row.name),
+                                    attribute: attribute,
+                                    type: type,
+                                    typeScriptStyle: typeScriptStyle,
+                                    alias: row.name
+                                });
+
+                                typeScriptStyle = false;
+                            }
+
+                            if (attribute != row.name) {
+                                fieldsInfos.push({
+                                    name: attribute,
+                                    attribute: attribute,
+                                    type: type,
+                                    typeScriptStyle: typeScriptStyle,
+                                    alias: row.name
+                                });
+
+                                typeScriptStyle = false;
+                            }
+
+                            fieldsInfos.push({
+                                name: row.name,
+                                attribute: attribute,
+                                type: type,
+                                physical: row.cid !== undefined,
+                                typeScriptStyle: typeScriptStyle
+                            });
+
+                            attributes[attribute] = type;
+
+                            if (relation.name == "user" && attribute == "name") {
+                                data += "    // @ts-ignore";
+                            }
+                            data += `    ${attribute}?: ${type};\n`;
+                        });
+
+                        data += "}\n\n";
+
+                        data += `export class ${className} extends AbstractModel<${className}, ${className}Data> {\n`;
+
+                        _.forEach(attributes, (type, attribute) => {
+                            data += `    private _${attribute}?: ${type};\n`;
+                        });
+
+                        data += "\n";
+
+                        data += "    static readonly attributeMap: ModelAttributeMap = {\n";
+
+                        fieldsInfos.forEach((info, idx) => {
+                            if (idx > 0) {
+                                data += ",\n";
+                            }
+
+                            data += `        ${info.name}: {\n`;
+
+                            if (info.physical) {
+                                data += "            physical: true,\n";
+                            }
+
+                            if (info.alias) {
+                                data += `            alias: "${info.alias}",\n`;
+                            }
+
+                            if (info.virtual) {
+                                data += "            virtual: true,\n";
+                            }
+
+                            if (info.typeScriptStyle) {
+                                data += "            typeScriptStyle: true,\n";
+                            }
+
+                            data += `            type: "${info.type}",\n`;
+                            data += `            attribute: "_${info.attribute}"\n`;
+                            data += "        }";
+                        });
+
+                        data += "\n";
+                        data += "    };\n";
+
+                        data += "\n";
+                        data += "    static getClassName(): string {\n";
+                        data += `        return "${className}";\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += "    static getTableName(): string {\n";
+                        data += `        return "${relation.name}";\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += "    static getPrimaryKey(): string {\n";
+                        data += `        return "${pkName}";\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += `    static from(other: ${className} | ${className}Data): ${className} {\n`;
+                        data += `        let value: ${className} = null;\n`;
+                        data += "        if (other) {\n";
+                        data += `            value = new ${className}();\n`;
+                        data += `            if (other instanceof ${className}) {\n`;
+                        data += "                Object.assign(value, other);\n";
+                        data += "            } else {\n";
+                        data += "                value.assign(other);\n";
+                        data += "            }\n";
+                        data += "        }\n";
+                        data += "        return value;\n";
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += `    constructor(data?: ${className} | ${className}Data) {\n`;
+                        data += "        super();\n";
+                        data += "        if (data) {\n";
+                        data += "            this.assign(data);\n";
+                        data += "        }\n";
+                        data += "    }\n";
+
+
+                        data += "\n";
+                        data += `    public clone(): ${className} {\n`;
+                        data += `        return ${className}.from(this);\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += "    public getClassName(): string {\n";
+                        data += `        return "${className}";\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += "    public getTableName(): string {\n";
+                        data += `        return "${relation.name}";\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += "    public getPrimaryKey(): string {\n";
+                        data += `        return "${pkName}";\n`;
+                        data += "    }\n";
+
+                        data += "\n";
+                        data += "    public getAttributeMap(): ModelAttributeMap {\n";
+                        data += `        return ${className}.attributeMap;\n`;
+                        data += "    }\n";
+
+                        fieldsInfos.forEach((info) => {
+                            data += "\n";
+
+                            let noInspection: string;
+
+                            if (info.name.length < 3 || info.name.match(/_/)) {
+                                noInspection = "FunctionNamingConventionJS";
+                            } else {
+                                noInspection = "";
+                            }
+
+                            if (noInspection !== "") {
+                                data += `    // noinspection ${noInspection}\n`;
+                            }
+
+                            data += `    get ${info.name}(): ${info.type} {\n`;
+                            data += `        return this._${info.attribute};\n`;
+                            data += "    }\n\n";
+
+                            if (noInspection !== "") {
+                                data += `    // noinspection ${noInspection}\n`;
+                            }
+
+                            data += `    set ${info.name}(${info.attribute}: ${info.type}) {\n`;
+                            data += `        this._${info.attribute} = ${info.attribute};\n`;
+                            data += "    }\n";
+                        });
+
+                        data += "}\n";
+
+                        data = header + "\n" + data;
+                        const filename = relation.name.replace(/[^[a-z0-9]/g, "-") + "-model.ts";
+                        fs.writeFileSync(`${options.modelDirectory}/${filename}`, data);
+                    } else {
+                        console.log("error: table has no fields");
+                    }
+                }).catch((err) => {
+                    console.error(err);
+                    process.abort();
+                });
+            }
+        });
+
+        let smartDbDictionaryFile = `import {AbstractModel} from "${options.abstractModelModule}";\n`;
+
+        _.forEach(dictionaryRelations, (relation) => {
+            smartDbDictionaryFile += `import {${relation}} from "./${_.kebabCase(relation)}";\n`;
+        });
+
+        smartDbDictionaryFile += "\n";
+        smartDbDictionaryFile += "interface SmartDbDictionaryEntry {\n";
+
+        smartDbDictionaryFile += "    cls: " + dictionaryRelations.map((relation) => {
+            return "typeof " + relation;
+        }).join(" |\n         ");
+
+        smartDbDictionaryFile += ";\n";
+        smartDbDictionaryFile += "}\n\n";
+
+        smartDbDictionaryFile += "export class SmartDbDictionary {\n";
+        smartDbDictionaryFile += "    static models: { [relation: string]: SmartDbDictionaryEntry; } = {\n";
+
+        _.forEach(dictionaryRelations, (relation) => {
+            smartDbDictionaryFile += `        ${relation}: {\n`;
+            smartDbDictionaryFile += `            cls: ${relation}\n`;
+            smartDbDictionaryFile += `        },\n`;
+        });
+
+        smartDbDictionaryFile = smartDbDictionaryFile.substring(0, smartDbDictionaryFile.length - 2) + "\n";
+
+        smartDbDictionaryFile += "    };\n";
+
+        if (false) {
+            smartDbDictionaryFile += "\n";
+            smartDbDictionaryFile += "    static createModel(relationName: string): AbstractModel {\n";
+            smartDbDictionaryFile += "        const entry = SmartDbDictionary.models[relationName];\n";
+            smartDbDictionaryFile += "        return entry && entry.cls && new (entry.cls)();\n";
+            smartDbDictionaryFile += "    }\n";
+        }
+
+        smartDbDictionaryFile += "}\n";
+
+        fs.writeFileSync(`${options.modelDirectory}/smart-db-dictionary.ts`, smartDbDictionaryFile);
+    }
+
+    options.db.closeSync();
+}
+
+(() => {
+    if (process.argv.length == 4) {
+        const options: ExtractOptions = {
+            modelDirectory: process.argv[3],
+            smartDbInterfaces: "@egi/smart-db/smart-db-api",
+            abstractModelModule: "@egi/smart-db/smart-db-api",
+            db: new SmartDbBetterSqlite3(process.argv[2], {
+                verbose: (message?: any, ...additionalArgs: any[]) => {
+                    console.log("DB LOG", message, ...additionalArgs);
+                }
+            })
+        };
+
+        extractDbApi(options);
+    } else if (process.argv.length == 2 && fs.existsSync("src/helpers/extract-db-api.ts")) {
+        const tmpName = `/tmp/smart-db-core.${process.pid}.sqlite3`;
+
+        const smartDbOptions: ExtractOptions = {
+            includeCoreTables: true,
+            modelDirectory: "src/models",
+            smartDbInterfaces: "../smart-db-interfaces",
+            abstractModelModule: "./abstract-models",
+            db: new SmartDbBetterSqlite3(tmpName, {
+                verbose: (message?: any, ...additionalArgs: any[]) => {
+                    console.log("DB LOG", message, ...additionalArgs);
+                }
+            })
+        };
+
+        smartDbOptions.db.initDb({
+            module: "smart-db-core",
+            sqlFilesDirectory: "assets/sqlite3"
+        }).then(() => {
+            extractDbApi(smartDbOptions);
+            fs.unlinkSync(tmpName);
+            smartDbOptions.db.closeSync();
+        });
+
+        if (false) {
+            if (fs.existsSync("test/test.sqlite3")) {
+                fs.unlinkSync("test/test.sqlite3");
+            }
+
+            const testDbOptions: ExtractOptions = {
+                modelDirectory: "test/models",
+                smartDbInterfaces: "../../src/smart-db-interfaces",
+                abstractModelModule: "../../src/models/abstract-models",
+                db: new SmartDbBetterSqlite3("test/db/sqlite3.db", {
+                    verbose: (message?: any, ...additionalArgs: any[]) => {
+                        console.log("DB LOG", message, ...additionalArgs);
+                    }
+                })
+            };
+
+            testDbOptions.db.initDb({
+                module: "smart-db-test",
+                sqlFilesDirectory: "test/db/sqlite3"
+            }).then(() => {
+                extractDbApi(testDbOptions);
+            });
+        }
+    } else {
+        console.log("usage: extract-db-api {db-connector|path-to-db} {target-models-directory}");
+    }
+})();

package/src/helpers/terser-tree.ts

@@ -0,0 +1,39 @@
+/* eslint-disable */
+import fs from "fs";
+import glob from "glob";
+import process from "process";
+import Terser from "Terser";
+
+const globStrings = process.argv.slice(2);
+
+globStrings.forEach((globString) => {
+    glob(globString, null, (err, files) => {
+        if (err) {
+            console.error(err);
+            process.exit(1);
+        } else {
+            files.forEach((file) => {
+                if (file.match(/\.js$/)) {
+                    const data: Record<string, string> = {};
+                    data[file] = fs.readFileSync(file, "utf8");
+
+                    const result = Terser.minify(data, {
+                        sourceMap: true
+                    });
+
+                    if (result.error) {
+                        console.error("error", file, result.error);
+                    } else {
+                        if (result.warnings) {
+                            console.warn("warning", file, result.warnings);
+                        }
+
+                        console.log("tersed", file);
+
+                        fs.writeFileSync(file, result.code);
+                    }
+                }
+            });
+        }
+    });
+});