namirasoft-sdk-generator 1.1.0

package/src/npm/NPMBuilder.ts

@@ -0,0 +1,232 @@
+import { ApplicationLooper, BaseTypeSchema, ControllerSchema, ObjectSchema, TypeLooper } from "namirasoft-schema";
+import { HTTPMethod } from "namirasoft-core";
+
+import { BaseBuilder } from "../BaseBuilder";
+import { Ts } from "./Ts";
+import { TypeBuilder } from "./TypeBuilder";
+
+export class NPMBuilder extends BaseBuilder
+{
+    protected override async _run()
+    {
+        // folder
+        await this.dst.mkFolder("src");
+        await this.dst.mkFolder("src/row");
+        // copy
+        await this.copy("logo.png", "logo.png");
+        // download
+        await this.dst.download("https://static.namirasoft.com/template/node/.gitignore", ".gitignore");
+        await this.dst.download("https://static.namirasoft.com/template/node/ts/tsconfig.json", "tsconfig.json");
+        await this.dst.download("https://static.namirasoft.com/template/gitlab-ci.yml/js/npm-publish.yml", ".gitlab-ci.yml");
+
+        let json: any = {
+            name: this.name,
+            description: this.description + " NPM Package",
+            "icon": "logo.png",
+            "version": "1.1.0",
+            "main": "./dist/index.js",
+            "types": "./dist/index.d.ts",
+            "scripts": {},
+            "author": "Amir Abolhasani",
+            "license": "MIT",
+            "dependencies": {
+                "namirasoft-core": "^1.1.0"
+            }
+        };
+        if (this.account)
+            json.dependencies["namirasoft-account"] = "^1.1.0";
+        // file
+        this.dst.saveFileJson("package.json", json);
+        // command
+        await this.dst.exec("ncu -u");
+        await this.dst.exec("npm i");
+        // codes
+        let looper = new ApplicationLooper(this.schema);
+        let objs = await looper.getObjects(true);
+        let tags = [...new Set(this.schema.controllers.map(c => c.tag))];
+        let rows: Ts[] = [];
+        for (let i = 0; i < objs.length; i++)
+        {
+            const obj = objs[i];
+            let c = await this.getRow(obj);
+            rows.push(c);
+        }
+        let server = this.getServer(tags);
+        let server_base = this.getServerBase();
+        let server_tags: { [tag: string]: Ts } = {};
+        let servers: Ts[] = [];
+        tags.forEach(tag =>
+        {
+            let s = this.getServerTag(tag);
+            server_tags[tag] = s;
+            servers.push(s);
+        });
+        for (let i = 0; i < this.schema.controllers.length; i++)
+        {
+            const c = this.schema.controllers[i];
+            await this.addFunction(c, server_tags[c.tag]);
+        }
+        let all = [...rows, server, server_base, ...servers];
+        let index = this.getIndex(...all);
+        all.forEach(x => this.save(x));
+        this.save(index);
+        // command
+        await this.dst.exec("tsc");
+    }
+    save(ts: Ts)
+    {
+        this.dst.saveFileText(ts.getFilePath(), ts.getContent());
+    }
+    getIndex(...all: Ts[]): Ts
+    {
+        let ts = new Ts("./src", "", "index", "", false);
+        all.forEach(x => ts.imports.push(`export * from "${x.exportPath}/${x.name}";`))
+        return ts;
+    }
+    async getRow(schema: ObjectSchema): Promise<Ts>
+    {
+        let name = TypeBuilder.getClassName(schema.name);
+        let ts = new Ts("./src/row", "./row", name, undefined, false);
+        ts.scripts.push(`export type ${name} = `);
+        ts.scripts.push(`{`);
+        if (schema.fields)
+            for (let i = 0; i < schema.fields.length; i++)
+            {
+                const field = schema.fields[i];
+                let build = new TypeBuilder(field.type);
+                let type = await build.run();
+                ts.scripts.push(`    ${field.name}: ${type};`);
+                if (field.name)
+                {
+                    let looper = new TypeLooper(field.type);
+                    let rows = await looper.getObjects(true);
+                    if (rows)
+                    {
+                        for (let j = 0; j < rows.length; j++)
+                        {
+                            const row = rows[j];
+                            let typename = TypeBuilder.getClassName(row.name);
+                            ts.imports.push(`import { ${typename} } from "./${typename}";`);
+                        }
+                    }
+                }
+            }
+        ts.scripts.push(`}`);
+        return ts;
+    }
+    getServer(tags: string[]): Ts
+    {
+        let className = this.title.replace(/\s/gm, "") + "Server";
+        let ts = new Ts("./src", "./", className);
+        ts.imports.push(`import { TokenManager } from "namirasoft-account";`);
+        tags.forEach(tag => ts.imports.push(`import { ${className}${tag} } from "./${className}${tag}";`));
+        tags.forEach(tag => ts.fields.push(`${tag.toLowerCase()}: ${className}${tag};`));
+        ts.constructors.push(`constructor(manager: TokenManager, onError: (error: Error) => void)`);
+        ts.constructors.push(`{`);
+        if (this.account)
+            tags.forEach(tag => ts.constructors.push(`    this.${tag.toLowerCase()} = new ${className}${tag}(manager, onError);`));
+        else
+            tags.forEach(tag => ts.constructors.push(`    this.${tag.toLowerCase()} = new ${className}${tag}(onError);`));
+        ts.constructors.push(`}`);
+        return ts;
+    }
+    getServerBase(): Ts
+    {
+        let className = this.title.replace(/\s/gm, "") + "ServerBase";
+        let parentName = this.account ? "NamirasoftServerBase" : "BaseServer";
+        let ts = new Ts("./src", "./", className, parentName);
+        if (this.account)
+        {
+            ts.imports.push(`import { NamirasoftServerBase } from "namirasoft-account";`);
+            ts.imports.push(`import { TokenManager } from "namirasoft-account";`);
+        }
+        else
+        {
+            ts.imports.push(`import { BaseServer } from "namirasoft-core";`);
+        }
+        if (this.account)
+            ts.constructors.push(`constructor(manager: TokenManager, onError: (error: Error) => void)`);
+        else
+            ts.constructors.push(`constructor(onError: (error: Error) => void)`);
+        ts.constructors.push(`{`);
+        if (this.account)
+            ts.constructors.push(`    super("${this.url}", manager, onError);`);
+        else
+        {
+            ts.fields.push("protected onError;");
+            ts.constructors.push(`    super("${this.url}");`);
+            ts.constructors.push(`    this.onError = onError;`);
+            ts.functions.push(`protected override onBeforeRequest()`);
+            ts.functions.push(`{`);
+            ts.functions.push(`}`);
+            ts.functions.push(`protected onAfterRequest()`);
+            ts.functions.push(`{`);
+            ts.functions.push(`}`);
+        }
+        ts.constructors.push(`}`);
+        return ts;
+    }
+    getServerTag(tag: string): Ts
+    {
+        let baseName = this.title.replace(/\s/gm, "") + "Server";
+        let parentName = baseName + "Base";
+        let className = baseName + tag;
+        let ts = new Ts("./src", "./", className, parentName);
+        ts.imports.push(`import { ${parentName} } from "./${parentName}";`);
+        return ts;
+    }
+    async addFunction(schema: ControllerSchema, ts: Ts): Promise<void>
+    {
+        let pars = [];
+        for (let i = 0; i < schema.parameters.length; i++)
+        {
+            const parameter = schema.parameters[i];
+            let parameter_type = await this.addFunction_GetType(parameter.type, ts);
+            pars.push(parameter.name + ": " + parameter_type);
+        }
+        let queries = [];
+        for (let i = 0; i < schema.queries.length; i++)
+        {
+            const parameter = schema.queries[i];
+            let parameter_type = await this.addFunction_GetType(parameter.type, ts);
+            pars.push(parameter.name + ": " + parameter_type);
+            queries.push(`${parameter.name}`);
+        }
+        let body = "";
+        if (schema.body)
+        {
+            let parameter_type = await this.addFunction_GetType(schema.body, ts);
+            pars.push("body" + ": " + parameter_type);
+            body = ", body";
+        }
+        let type_output = await this.addFunction_GetType(schema.output, ts);
+        let query = "{ " + queries.join(",") + " }"
+        ts.functions.push(`async ${schema.name}(${pars.join(", ")}): Promise<${type_output}>`);
+        ts.functions.push(`{`);
+        ts.functions.push(`    let path = \`${schema.path.replace(/\{/gm, '${')}\`;`);
+        ts.functions.push(`    let { data } = await this._${HTTPMethod[schema.method].toLowerCase()}<${type_output}>(path, ${query}${body});`);
+        ts.functions.push(`    return data;`);
+        ts.functions.push(`}`);
+    }
+    async addFunction_GetType(schema: BaseTypeSchema | null, ts: Ts): Promise<string>
+    {
+        let type_output = null;
+        if (schema)
+        {
+            let builder = new TypeBuilder(schema);
+            type_output = await builder.run();
+            let looper = new TypeLooper(schema, false);
+            let rows = await looper.getObjects(true);
+            if (rows)
+            {
+                for (let j = 0; j < rows.length; j++)
+                {
+                    const row = rows[j];
+                    let typename = TypeBuilder.getClassName(row.name);
+                    ts.imports.push(`import { ${typename} } from "./row/${typename}";`);
+                }
+            }
+        }
+        return type_output ?? "string";
+    }
+}

package/src/npm/Ts.ts

@@ -0,0 +1,56 @@
+import * as path from "path";
+export class Ts
+{
+    path: string;
+    exportPath: string;
+    name: string;
+    parent_name: string;
+    has_class: boolean;
+    imports: string[] = [];
+    scripts: string[] = [];
+    fields: string[] = [];
+    constructors: string[] = [];
+    functions: string[] = [];
+    constructor(path: string, exportPath: string, name: string, parent_name: string = "", has_class: boolean = true)
+    {
+        this.path = path;
+        this.exportPath = exportPath;
+        this.name = name;
+        this.parent_name = parent_name;
+        this.has_class = has_class;
+    }
+    getFilePath(): string
+    {
+        let ans = path.join(this.path, this.name + ".ts");
+        if (this.path.startsWith("./"))
+            if (!ans.startsWith("./"))
+                ans = "./" + ans;
+        return ans;
+    }
+    getContent(): string
+    {
+        let lines = [];
+        if (this.imports.length > 0)
+        {
+            let is = [...new Set(this.imports)];
+            is.sort();
+            lines.push(...is);
+            lines.push("");
+        }
+        if (this.scripts.length > 0)
+        {
+            lines.push(...this.scripts);
+            lines.push("");
+        }
+        if (this.has_class)
+        {
+            lines.push("export class " + this.name + (this.parent_name ? (" extends " + this.parent_name) : ""));
+            lines.push("{");
+            lines.push(...(this.fields.map(x => "    " + x)));
+            lines.push(...(this.constructors.map(x => "    " + x)));
+            lines.push(...(this.functions.map(x => "    " + x)));
+            lines.push("}");
+        }
+        return lines.join("\n");
+    }
+}

package/src/npm/TypeBuilder.ts

@@ -0,0 +1,106 @@
+import { AnySchema, ArraySchema, BaseTypeBuilder, BaseTypeSchema, BigIntSchema, BoolSchema, DateSchema, DateTimeSchema, DecimalSchema, DoubleSchema, FloatSchema, IntegerSchema, MediumIntSchema, ObjectSchema, RealSchema, SmallIntSchema, StringSchema, TimeSchema, TinyIntSchema } from "namirasoft-schema";
+import { EnumSchema } from "namirasoft-schema/dist/schema/type/EnumSchema";
+
+export class TypeBuilder extends BaseTypeBuilder<string>
+{
+    private toBase(schema: BaseTypeSchema, type: string): string
+    {
+        if (!schema.required)
+            type += " | null";
+        return type;
+    }
+    protected override async _toAny(schema: AnySchema)
+    {
+        return this.toBase(schema, "any");
+    }
+    protected override async _toBool(schema: BoolSchema)
+    {
+        return this.toBase(schema, "boolean");
+    }
+    protected override async _toTinyInt(schema: TinyIntSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toSmallInt(schema: SmallIntSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toMediumInt(schema: MediumIntSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toInteger(schema: IntegerSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toBigInt(schema: BigIntSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toFloat(schema: FloatSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toDouble(schema: DoubleSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toDecimal(schema: DecimalSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toReal(schema: RealSchema)
+    {
+        return this.toBase(schema, "number");
+    }
+    protected override async _toString(schema: StringSchema)
+    {
+        return this.toBase(schema, "string");
+    }
+    protected override async _toDateTime(schema: DateTimeSchema)
+    {
+        return this.toBase(schema, "Date");
+    }
+    protected override async _toDate(schema: DateSchema)
+    {
+        return this.toBase(schema, "");
+    }
+    protected override async _toTime(schema: TimeSchema)
+    {
+        return this.toBase(schema, "");
+    }
+    protected override async _toEnum(schema: EnumSchema)
+    {
+        return this.toBase(schema, "");
+    }
+    protected override async _toArray(schema: ArraySchema)
+    {
+        let names: string[] = [];
+        for (let i = 0; i < schema.items.length; i++)
+        {
+            const item = schema.items[i];
+            let builder = new TypeBuilder(item);
+            let name = await builder.run();
+            names.push(name ?? "any");
+        }
+        names = [... new Set(names)];
+        let ans = "";
+        if (names.length == 0)
+            ans = "any";
+        else if (names.length == 1)
+            ans = names[0];
+        else
+            ans = "(" + names.join(" | ") + ")";
+        return this.toBase(schema, ans + "[]");
+    }
+    protected override async _toObject(schema: ObjectSchema)
+    {
+        return this.toBase(schema, TypeBuilder.getClassName(schema.name));
+    }
+    static getClassName(name: string): string
+    {
+        let ns = name.split('_');
+        ns = ns.map(n => n[0].toUpperCase() + n.substring(1).toLowerCase());
+        return ns.join("") + "Row";
+    }
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "CommonJS",
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "allowJs": false,
+        "checkJs": false,
+        "strict": true,
+        "esModuleInterop": true,
+        "sourceMap": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "noImplicitOverride": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "skipLibCheck": false,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "noFallthroughCasesInSwitch": true,
+        "isolatedModules": false,
+    }
+}