@egi/smart-db 2.3.2 → 2.3.4

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

@@ -1,465 +0,0 @@
-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

@@ -1,39 +0,0 @@
-/* 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);
-                    }
-                }
-            });
-        }
-    });
-});