@zuzjs/orm 0.1.1

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const commander_1 = require("commander");
+// import fs, { readdirSync } from "fs";
+// import { fileURLToPath } from "url";
+const index_js_1 = require("./drivers/mysql/index.js");
+const index_js_2 = require("./core/index.js");
+commander_1.program
+    .option(`-v, --version`)
+    .option(`-c, --connection <VALUE>`, `Database Connection String`)
+    .option(`-p, --dist`);
+commander_1.program.parse();
+const { version, connection, dist: destination } = commander_1.program.opts();
+if (version) {
+    console.log(`ZuzORM v0.1.1`);
+    process.exit(1);
+}
+if (connection) {
+    const dist = destination || path_1.default.join(`src`, `zorm`);
+    const _checkDist = (0, index_js_2.checkDirectory)(path_1.default.join(process.cwd(), dist), true);
+    if (!_checkDist.access) {
+        console.log(picocolors_1.default.red(`○ ${_checkDist.message}`));
+        process.exit(1);
+    }
+    if (connection.startsWith(`mysql`)) {
+        const driver = new index_js_1.MySqlDriver(decodeURIComponent(connection), dist);
+        driver.generate();
+    }
+    else {
+        console.log(`Only MySQL is supported for now`);
+        process.exit(1);
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export declare const toPascalCase: (str: string) => string;
+export declare const mapSqlTypeToTypescript: (sqlType: string) => string;
+export declare const checkDirectory: (path: string, create: boolean) => {
+    access: boolean;
+    message?: string;
+};
+export declare const stackTrace: (_error: string, ...more: string[]) => Error;

package/dist/core/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stackTrace = exports.checkDirectory = exports.mapSqlTypeToTypescript = exports.toPascalCase = void 0;
+const fs_1 = __importDefault(require("fs"));
+const toPascalCase = (str) => {
+    return str.replace(/(^\w|_\w)/g, (match) => match.replace("_", "").toUpperCase());
+};
+exports.toPascalCase = toPascalCase;
+const mapSqlTypeToTypescript = (sqlType) => {
+    if (sqlType.startsWith("int") || sqlType.startsWith("tinyint"))
+        return "number";
+    if (sqlType.startsWith("varchar") || sqlType.startsWith("text"))
+        return "string";
+    if (sqlType.startsWith("datetime") || sqlType.startsWith("timestamp"))
+        return "Date";
+    return "any";
+};
+exports.mapSqlTypeToTypescript = mapSqlTypeToTypescript;
+const checkDirectory = (path, create) => {
+    try {
+        // Check if the path exists
+        if (!fs_1.default.existsSync(path)) {
+            if (create)
+                fs_1.default.mkdirSync(path, { recursive: true });
+            else
+                return { access: false, message: `${path} does not exist.\nRun \`zorm -c [DATABASE_CONNECTION_STRING]\`` };
+        }
+        // Check if it's a directory
+        const stat = fs_1.default.statSync(path);
+        if (!stat.isDirectory())
+            return { access: false, message: `${path} is not a folder.` };
+        // Check if it's writable
+        try {
+            fs_1.default.accessSync(path, fs_1.default.constants.W_OK);
+        }
+        catch (e) {
+            return { access: false, message: `${path} has no write permission.` };
+        }
+        return { access: true };
+    }
+    catch (err) {
+        return { access: false, message: `Destination folder is not accessible` };
+    }
+};
+exports.checkDirectory = checkDirectory;
+const stackTrace = (_error, ...more) => {
+    const error = new Error([_error, ...more].join(` `));
+    const lines = [error.message];
+    // const lines : string[] = [`${pc.bgRed(pc.whiteBright(` Zorm `))} ${pc.red(error.message)}`]
+    // const regex = /\((\/.*\.[a-zA-Z0-9]+):\d+:\d+\)/;
+    // const regex = /(\/.*\.[a-zA-Z0-9]+):\d+:\d+/;
+    // error.stack?.split(`\n`)
+    //     .forEach((line, index) => {
+    //         if ( line.includes(process.cwd()) ){
+    //             const match = line.match(regex)
+    //             if ( match ){
+    //                 const [f, _line, _column] = match[0].split(`:`)
+    //                 const rawLine = fs.readFileSync(match[1], `utf8`).split(`\n`)[Number(_line)-1]
+    //                 const ls = f.split(`/`)
+    //                 lines.push(`${ls[ls.length-3]}/${ls[ls.length-2]}/${ls[ls.length-1]} - ZormError: ${_error}`)
+    //                 lines.push(`${pc.bgBlack(pc.white(_line))}\t${rawLine}`)
+    //             }
+    //         }
+    //     })
+    return Error(lines.join(`\n`));
+};
+exports.stackTrace = stackTrace;

package/dist/drivers/mysql/index.d.ts

@@ -0,0 +1,38 @@
+import { Pool } from 'mysql2/promise';
+import { ConnectionDetails, ModelGenerator } from '../../types.js';
+export declare const parseConnectionString: (connectionString: string) => {
+    user: string;
+    password: string;
+    host: string;
+    port: number;
+    database: string;
+    params: {
+        [k: string]: string;
+    };
+};
+export declare const MySQLErrorMap: Record<string, string>;
+export declare class MySqlDriver implements ModelGenerator {
+    pool: Pool | null;
+    conn: ConnectionDetails;
+    dist: string | null;
+    constructor(connectionString: string, dist?: string);
+    connection(): ConnectionDetails;
+    parseConnectionString: (connectionString: string) => {
+        user: string;
+        password: string;
+        host: string;
+        port: number;
+        database: string;
+        params: {
+            [k: string]: string;
+        };
+    };
+    createPool(): void;
+    mapColumns(sqlType: string): {
+        tsType: string;
+        columnType: string;
+        length?: number;
+    };
+    formatDefault(value: any, tsType: string): string | number;
+    generate(): Promise<void>;
+}

package/dist/drivers/mysql/index.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlDriver = exports.MySQLErrorMap = exports.parseConnectionString = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const index_js_1 = require("../../core/index.js");
+const parseConnectionString = (connectionString) => {
+    const regex = /mysql:\/\/(?<user>[^:]+):(?<password>[^@]+)@(?<host>[^:/]+)(?::(?<port>\d+))?\/(?<database>[^?]+)(?:\?(?<params>.+))?/;
+    const match = connectionString.match(regex);
+    if (!match || !match.groups) {
+        throw new Error("Invalid MySQL connection string");
+    }
+    const { user, password, host, port, database, params } = match.groups;
+    const queryParams = params ? Object.fromEntries(new URLSearchParams(params)) : {};
+    return { user, password, host, port: port ? Number(port) : 3306, database, params: queryParams };
+};
+exports.parseConnectionString = parseConnectionString;
+exports.MySQLErrorMap = {
+    ER_DUP_ENTRY: "DuplicateEntry",
+    ER_NO_REFERENCED_ROW: "ForeignKeyConstraintFails",
+    ER_NO_REFERENCED_ROW_2: "ForeignKeyConstraintFails",
+    ER_BAD_NULL_ERROR: "NullValueNotAllowed",
+    ER_PARSE_ERROR: "SQLSyntaxError",
+    ER_ACCESS_DENIED_ERROR: "AccessDenied",
+    ER_TABLE_EXISTS_ERROR: "TableAlreadyExists",
+    ER_NO_SUCH_TABLE: "TableNotFound",
+    ER_LOCK_WAIT_TIMEOUT: "LockWaitTimeout",
+    ER_LOCK_DEADLOCK: "DeadlockDetected",
+    ER_DATA_TOO_LONG: "DataTooLong",
+    ER_TRUNCATED_WRONG_VALUE: "InvalidDataFormat",
+    ER_WRONG_VALUE_COUNT_ON_ROW: "WrongValueCount",
+    ER_CANT_CREATE_TABLE: "TableCreationFailed",
+    ER_CANT_DROP_FIELD_OR_KEY: "CannotDropKey",
+    ER_ROW_IS_REFERENCED: "RowReferenced",
+    ER_ROW_IS_REFERENCED_2: "RowReferenced",
+    ER_PRIMARY_CANT_HAVE_NULL: "PrimaryKeyCannotBeNull",
+    ER_KEY_COLUMN_DOES_NOT_EXITS: "KeyColumnNotFound",
+    ER_UNKNOWN_COLUMN: "UnknownColumn",
+    ER_WRONG_DB_NAME: "InvalidDatabaseName",
+    ER_WRONG_TABLE_NAME: "InvalidTableName",
+    ER_UNKNOWN_PROCEDURE: "ProcedureNotFound",
+    ER_DUP_UNIQUE: "UniqueConstraintViolation",
+    ER_SP_DOES_NOT_EXIST: "StoredProcedureNotFound",
+    ER_BAD_FIELD_ERROR: "InvalidColumn",
+};
+class MySqlDriver {
+    pool;
+    conn;
+    dist;
+    constructor(connectionString, dist) {
+        this.pool = null;
+        this.dist = dist || null;
+        this.conn = this.parseConnectionString(connectionString);
+    }
+    connection() {
+        return this.conn;
+    }
+    parseConnectionString = (connectionString) => {
+        const regex = /mysql:\/\/(?<user>[^:]+):(?<password>[^@]+)@(?<host>[^:/]+)(?::(?<port>\d+))?\/(?<database>[^?]+)(?:\?(?<params>.+))?/;
+        const match = connectionString.match(regex);
+        if (!match || !match.groups) {
+            throw new Error("Invalid MySQL connection string");
+        }
+        const { user, password, host, port, database, params } = match.groups;
+        const queryParams = params ? Object.fromEntries(new URLSearchParams(params)) : {};
+        return { user, password, host, port: port ? Number(port) : 3306, database, params: queryParams };
+    };
+    createPool() {
+        if (!this.pool) {
+            try {
+                this.pool = promise_1.default.createPool({
+                    user: this.conn.user,
+                    password: this.conn.password,
+                    host: this.conn.host,
+                    port: this.conn.port,
+                    database: this.conn.database,
+                    ...this.conn.params
+                });
+                this.pool.getConnection()
+                    .then((connection) => {
+                    console.log(picocolors_1.default.green("✓ MySQL Connected..."));
+                    connection.release();
+                })
+                    .catch((err) => {
+                    console.error(picocolors_1.default.red("○ Error while connecting to your MySQL Server with following error:"), err);
+                    process.exit(1); // Exit process if connection fails
+                });
+            }
+            catch (error) {
+                console.error(picocolors_1.default.red("○ Error while connecting to your MySQL Server with following error:"), error);
+                process.exit(1);
+            }
+        }
+    }
+    mapColumns(sqlType) {
+        const typeMap = {
+            "int": { tsType: "number", columnType: "int" },
+            "tinyint": { tsType: "boolean", columnType: "tinyint" },
+            "smallint": { tsType: "number", columnType: "smallint" },
+            "mediumint": { tsType: "number", columnType: "mediumint" },
+            "bigint": { tsType: "string", columnType: "bigint" }, // bigint is safer as string
+            "decimal": { tsType: "string", columnType: "decimal" },
+            "float": { tsType: "number", columnType: "float" },
+            "double": { tsType: "number", columnType: "double" },
+            "varchar": { tsType: "string", columnType: "varchar", length: 255 },
+            "text": { tsType: "string", columnType: "text" },
+            "longtext": { tsType: "string", columnType: "longtext" },
+            "char": { tsType: "string", columnType: "char", length: 1 },
+            "datetime": { tsType: "Date", columnType: "datetime" },
+            "timestamp": { tsType: "Date", columnType: "timestamp" },
+            "date": { tsType: "Date", columnType: "date" },
+            "time": { tsType: "string", columnType: "time" },
+            "json": { tsType: "any", columnType: "json" },
+        };
+        const match = sqlType.match(/^(\w+)(?:\((\d+)\))?/);
+        if (!match)
+            return { tsType: "any", columnType: "varchar", length: 255 };
+        const baseType = match[1].toLowerCase();
+        const length = match[2] ? parseInt(match[2], 10) : undefined;
+        return typeMap[baseType] ? { ...typeMap[baseType], length: length || typeMap[baseType].length } : { tsType: "any", columnType: "varchar", length: 255 };
+    }
+    formatDefault(value, tsType) {
+        if (tsType === "number")
+            return Number(value);
+        if (tsType === "boolean")
+            return value === "1" ? "true" : "false";
+        return `"${value}"`;
+    }
+    async generate() {
+        const self = this;
+        self.createPool();
+        //Extract Tables
+        console.log(picocolors_1.default.cyan("○ Extract Tables..."));
+        const [tables] = await self.pool.execute("SHOW TABLES");
+        console.log(picocolors_1.default.cyan(`○ ${tables.length} Tables Found.`));
+        const tableNames = tables.map((row) => Object.values(row)[0]);
+        console.log(picocolors_1.default.yellow(`○ Generating Models...`));
+        for (const tableName of tableNames) {
+            // Get table structure
+            const [columns] = await self.pool.execute(`DESCRIBE ${tableName}`);
+            const entityCode = [
+                `import { Entity, PrimaryColumn, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm";\n`,
+                `@Entity({ name: "${tableName}" })`,
+                `export class ${(0, index_js_1.toPascalCase)(tableName)} extends BaseEntity {\n`
+            ];
+            for (const column of columns) {
+                // const { Field, Type, Key } = column;
+                const { Field, Type, Key, Null, Default, Extra } = column;
+                const { tsType, columnType, length } = this.mapColumns(Type);
+                // Handle primary key
+                if (Key === "PRI") {
+                    entityCode.push(Extra.includes("auto_increment") ? `\t@PrimaryGeneratedColumn()` : `\t@PrimaryColumn()`);
+                }
+                else {
+                    let columnDecorator = `\t@Column({ type: "${columnType}"`;
+                    if (length)
+                        columnDecorator += `, length: ${length}`;
+                    if (Null === "YES")
+                        columnDecorator += `, nullable: true`;
+                    if (Default !== null)
+                        columnDecorator += `, default: ${this.formatDefault(Default, tsType)}`;
+                    columnDecorator += ` })`;
+                    entityCode.push(columnDecorator);
+                }
+                entityCode.push(`\t${Field}!: ${tsType};\n`);
+            }
+            entityCode.push(`}`);
+            // Write entity file
+            fs_1.default.writeFileSync(path_1.default.join(this.dist, `${tableName}.ts`), entityCode.join(`\n`));
+        }
+        await self.pool.end();
+        console.log(picocolors_1.default.green(`✓ ${tables.length} Tables Processed.`));
+        process.exit(1);
+    }
+}
+exports.MySqlDriver = MySqlDriver;

package/dist/drivers/queryBuilder.d.ts

@@ -0,0 +1,42 @@
+import { Repository, ObjectLiteral, FindOptionsWhere } from "typeorm";
+import { QueryAction } from "../types";
+import { QueryResult } from "mysql2";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends Promise<R> {
+    private repository;
+    private queryBuilder;
+    private entityAlias;
+    private action;
+    private queryValues;
+    private usePromise;
+    private whereCount;
+    constructor(repository: Repository<T>, _action: QueryAction, _usePromise?: boolean);
+    _create(): this;
+    upsert(): this;
+    _update(): this;
+    _delete(): this;
+    _getRawQuery(): [string, any[]];
+    with(data: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T[]>): this;
+    select(fields: (keyof T)[]): this;
+    where(condition: FindOptionsWhere<T>): this;
+    or(condition: FindOptionsWhere<T>): this;
+    orderBy(field: keyof T, direction?: "ASC" | "DESC"): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    relations(relations: string[]): this;
+    innerJoin(relation: string, alias: string, condition?: string): this;
+    leftJoin(relation: string, alias: string, condition?: string): this;
+    groupBy(field: keyof T): this;
+    having(condition: string): this;
+    in(field: keyof T, values: any[]): this;
+    distinct(): this;
+    count(): Promise<number>;
+    sum(field: keyof T): Promise<number>;
+    avg(field: keyof T): Promise<number>;
+    min(field: keyof T): Promise<number>;
+    max(field: keyof T): Promise<number>;
+    rawQuery(sql: string, params?: any): Promise<any>;
+    execute(): Promise<R>;
+    then<TResult1 = R, TResult2 = never>(onfulfilled?: ((value: R) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+}
+export default ZormQueryBuilder;

package/dist/drivers/queryBuilder.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./mysql/index.js");
+const core_1 = require("../core");
+class ZormQueryBuilder extends Promise {
+    repository;
+    queryBuilder;
+    entityAlias;
+    action;
+    queryValues = null;
+    usePromise;
+    whereCount = 0;
+    constructor(repository, _action, _usePromise) {
+        super(() => { }); // Required for extending Promise
+        this.repository = repository;
+        this.entityAlias = repository.metadata.tableName;
+        this.queryBuilder = repository.createQueryBuilder(this.entityAlias);
+        this.action = _action;
+        this.usePromise = _usePromise || false;
+    }
+    _create() {
+        if (this.queryValues) {
+            this.queryBuilder = this.queryBuilder
+                .insert()
+                .into(this.entityAlias)
+                .values(this.queryValues);
+        }
+        else
+            throw (0, core_1.stackTrace)(`○ Values are missing. You forgot to call .with({ key: value })`);
+        return this;
+    }
+    upsert() {
+        if (this.queryValues) {
+            this.queryBuilder = this.repository.createQueryBuilder(this.entityAlias)
+                .insert()
+                .into(this.entityAlias)
+                .values(this.queryValues)
+                .orUpdate(Object.keys(this.queryValues));
+        }
+        else
+            throw (0, core_1.stackTrace)(`○ Values are missing. You forgot to call .with({ key: value })`);
+        return this;
+    }
+    _update() {
+        if (this.queryValues) {
+            if (this.whereCount > 0) {
+                this.queryBuilder = this.queryBuilder
+                    .update()
+                    .set(this.queryValues);
+            }
+            else {
+                throw (0, core_1.stackTrace)(`○ Update must have at least one WHERE condition. You forgot to call .where({ condition: value })`);
+            }
+        }
+        else
+            throw (0, core_1.stackTrace)(`○ Values are missing. You forgot to call .with({ key: value })`);
+        return this;
+    }
+    _delete() {
+        this.queryBuilder = this.queryBuilder.delete();
+        return this;
+    }
+    _getRawQuery() {
+        return this.queryBuilder.getQueryAndParameters();
+    }
+    with(data) {
+        this.queryValues = data;
+        return this;
+    }
+    select(fields) {
+        this.queryBuilder
+            .select(fields.map(field => `${this.entityAlias}.${String(field)}`));
+        return this;
+    }
+    where(condition) {
+        this.queryBuilder.where(condition);
+        this.whereCount++;
+        return this;
+    }
+    or(condition) {
+        this.queryBuilder.orWhere(condition);
+        return this;
+    }
+    orderBy(field, direction = "ASC") {
+        this.queryBuilder.orderBy(`${this.entityAlias}.${String(field)}`, direction);
+        return this;
+    }
+    limit(n) {
+        this.queryBuilder.limit(n);
+        return this;
+    }
+    offset(n) {
+        this.queryBuilder.offset(n);
+        return this;
+    }
+    relations(relations) {
+        relations.forEach(relation => this.queryBuilder.leftJoinAndSelect(`${this.entityAlias}.${relation}`, relation));
+        return this;
+    }
+    innerJoin(relation, alias, condition) {
+        if (condition) {
+            this.queryBuilder.innerJoin(`${this.entityAlias}.${relation}`, alias, condition);
+        }
+        else {
+            this.queryBuilder.innerJoin(`${this.entityAlias}.${relation}`, alias);
+        }
+        return this;
+    }
+    leftJoin(relation, alias, condition) {
+        if (condition) {
+            this.queryBuilder.leftJoin(`${this.entityAlias}.${relation}`, alias, condition);
+        }
+        else {
+            this.queryBuilder.leftJoin(`${this.entityAlias}.${relation}`, alias);
+        }
+        return this;
+    }
+    groupBy(field) {
+        this.queryBuilder.groupBy(`${this.entityAlias}.${String(field)}`);
+        return this;
+    }
+    having(condition) {
+        this.queryBuilder.having(condition);
+        return this;
+    }
+    in(field, values) {
+        this.queryBuilder.andWhere(`${this.entityAlias}.${String(field)} IN (:...values)`, { values });
+        return this;
+    }
+    distinct() {
+        this.queryBuilder.distinct(true);
+        return this;
+    }
+    async count() {
+        return await this.queryBuilder.getCount();
+    }
+    async sum(field) {
+        const result = await this.queryBuilder.select(`SUM(${this.entityAlias}.${String(field)})`, "sum").getRawOne();
+        return result.sum || 0;
+    }
+    async avg(field) {
+        const result = await this.queryBuilder.select(`AVG(${this.entityAlias}.${String(field)})`, "avg").getRawOne();
+        return result.avg || 0;
+    }
+    async min(field) {
+        const result = await this.queryBuilder.select(`MIN(${this.entityAlias}.${String(field)})`, "min").getRawOne();
+        return result.min || 0;
+    }
+    async max(field) {
+        const result = await this.queryBuilder.select(`MAX(${this.entityAlias}.${String(field)})`, "max").getRawOne();
+        return result.max || 0;
+    }
+    async rawQuery(sql, params) {
+        return await this.repository.query(sql, params);
+    }
+    async execute() {
+        try {
+            switch (this.action) {
+                case "upsert":
+                case "create":
+                    this._create();
+                    const _create = await this.queryBuilder.execute();
+                    // console.log(_create)
+                    return {
+                        created: true,
+                        id: _create.raw.insertId,
+                        record: _create.generatedMaps[0],
+                        records: _create.generatedMaps.length > 1 ? _create.generatedMaps : null
+                    };
+                case "update":
+                    this._update();
+                    const _update = await this.queryBuilder.execute();
+                    // console.log(`updated`, _update)
+                    return { updated: true };
+                case "delete":
+                    this._delete();
+                    const _delete = await this.queryBuilder.execute();
+                    return { deleted: true, count: _delete.affected || 0 };
+                case "select":
+                default:
+                    const _select = await this.queryBuilder.getMany();
+                    return {
+                        hasRows: true,
+                        count: _select.length,
+                        row: _select[0],
+                        rows: _select
+                    };
+            }
+        }
+        catch (err) {
+            const _e = err;
+            const error = {
+                code: index_js_1.MySQLErrorMap[_e.code] || _e.code,
+                message: _e.message,
+                query: _e.query, // The SQL query that caused the error
+                values: _e.parameters, // Parameters used in the query
+            };
+            switch (this.action) {
+                case "upsert":
+                case "create":
+                    const _c = {
+                        created: false,
+                        id: 0,
+                        error
+                    };
+                    return this.usePromise ? Promise.reject(_c) : _c;
+                case "update":
+                    const _u = { updated: false, error };
+                    return this.usePromise ? Promise.reject(_u) : _u;
+                case "delete":
+                    const _d = { deleted: false, error };
+                    return this.usePromise ? Promise.reject(_d) : _d;
+                case "select":
+                default:
+                    const _s = { hasRows: false, count: 0, row: null, rows: [], error };
+                    return this.usePromise ? Promise.reject(_s) : _s;
+            }
+        }
+    }
+    then(onfulfilled, onrejected) {
+        return this.execute().then(onfulfilled, onrejected);
+    }
+}
+exports.default = ZormQueryBuilder;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { EntitySchema, EntityTarget, MixedList, ObjectLiteral, Repository } from "typeorm";
+import ZormQueryBuilder from "./drivers/queryBuilder.js";
+import { InsertQueryResult, SelectQueryResult, UpdateQueryResult } from "./types.js";
+declare class Zorm {
+    private static instance;
+    private dataSource;
+    private initialized;
+    private usePromise;
+    private constructor();
+    static get(connectionString: string, entitiesPath?: string | null, usePromise?: boolean): Zorm;
+    connect(entities: MixedList<string | Function | EntitySchema<any>>): Promise<void>;
+    /**
+     * Returns the appropriate QueryBuilder based on the database type.
+     */
+    private getQueryBuilder;
+    /**
+     * Get a repository for a specific entity
+     */
+    getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
+    create<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, InsertQueryResult>;
+    find<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, SelectQueryResult>;
+    update<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, UpdateQueryResult>;
+    delete<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, UpdateQueryResult>;
+}
+export default Zorm;

package/dist/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const typeorm_1 = require("typeorm");
+const index_js_1 = require("./core/index.js");
+const picocolors_1 = __importDefault(require("picocolors"));
+const index_js_2 = require("./drivers/mysql/index.js");
+const queryBuilder_js_1 = __importDefault(require("./drivers/queryBuilder.js"));
+class Zorm {
+    static instance;
+    dataSource;
+    initialized = false;
+    usePromise = false;
+    constructor(connectionString, entitiesPath, usePromise) {
+        const _dist = entitiesPath || path_1.default.join(`src`, `zorm`);
+        const dist = path_1.default.join(process.cwd(), _dist);
+        const _checkDist = (0, index_js_1.checkDirectory)(dist, false);
+        this.usePromise = usePromise || false;
+        if (!_checkDist.access) {
+            console.log(picocolors_1.default.red(`○ ${_checkDist.message}`));
+            return;
+        }
+        if (connectionString.startsWith(`mysql`)) {
+            const driver = new index_js_2.MySqlDriver(decodeURIComponent(connectionString));
+            const conn = driver.connection();
+            this.dataSource = new typeorm_1.DataSource({
+                type: "mysql",
+                username: conn.user,
+                password: conn.password,
+                host: conn.host,
+                port: Number(conn.port),
+                database: conn.database
+            });
+        }
+        else {
+            console.log(`Only MySQL is supported for now`);
+            process.exit(1);
+        }
+    }
+    static get(connectionString, entitiesPath, usePromise) {
+        if (!Zorm.instance) {
+            Zorm.instance = new Zorm(connectionString, entitiesPath, usePromise);
+        }
+        return Zorm.instance;
+    }
+    async connect(entities) {
+        if (!this.initialized) {
+            try {
+                this.dataSource.setOptions({ entities });
+                await this.dataSource.initialize();
+                this.initialized = true;
+                console.log(picocolors_1.default.green("○ Zorm is connected"));
+            }
+            catch (e) {
+                console.log(picocolors_1.default.red("○ Error while connecting to your MySQL Server with following error:"), e);
+            }
+        }
+    }
+    /**
+     * Returns the appropriate QueryBuilder based on the database type.
+     */
+    getQueryBuilder(entity, action) {
+        const repository = this.getRepository(entity);
+        switch (this.dataSource.options.type) {
+            case "mysql":
+            case "mariadb":
+            case "postgres":
+            case "sqlite":
+            case "mssql":
+            case "oracle":
+                return new queryBuilder_js_1.default(repository, action, this.usePromise);
+            case "mongodb":
+                throw new Error("MongoDB does not support QueryBuilder. Use repository methods instead.");
+            default:
+                throw new Error(`Unsupported database type: ${this.dataSource.options.type}`);
+        }
+    }
+    /**
+     * Get a repository for a specific entity
+     */
+    getRepository(entity) {
+        return this.dataSource.getRepository(entity);
+    }
+    create(entity) {
+        return this.getQueryBuilder(entity, "create");
+    }
+    find(entity) {
+        return this.getQueryBuilder(entity, "select");
+    }
+    // upsert<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, InsertQueryResult> {
+    //     return this.getQueryBuilder(entity, "upsert");
+    // }
+    update(entity) {
+        return this.getQueryBuilder(entity, "update");
+    }
+    delete(entity) {
+        return this.getQueryBuilder(entity, "delete");
+    }
+}
+exports.default = Zorm;

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+import { ObjectLiteral } from "typeorm";
+export type dynamicObject = {
+    [x: string]: any;
+};
+export interface ModelGenerator {
+    generate: () => void;
+    connection: () => ConnectionDetails;
+    mapColumns: (sqlType: string) => void;
+}
+export type ConnectionDetails = {
+    host: string;
+    port: string | number;
+    user: string;
+    password: string;
+    database: string;
+    params: dynamicObject;
+};
+export type QueryAction = "create" | "upsert" | "select" | "update" | "delete";
+export type QueryResult = InsertQueryResult | SelectQueryResult | UpdateQueryResult | DeleteQueryResult;
+export type QueryError = {
+    code: number | string;
+    message: string;
+    query: string;
+    values: string[];
+};
+export type InsertQueryResult = {
+    created: boolean;
+    id?: number;
+    record?: ObjectLiteral;
+    records?: ObjectLiteral[];
+    error?: QueryError;
+};
+export type SelectQueryResult = {
+    hasRows: boolean;
+    count?: number;
+    row?: any;
+    rows?: any[];
+    error?: QueryError;
+};
+export type UpdateQueryResult = {
+    updated: boolean;
+    error?: QueryError;
+};
+export type DeleteQueryResult = {
+    deleted: boolean;
+    count: number;
+    error?: QueryError;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@zuzjs/orm",
+    "version": "0.1.1",
+    "keywords": [
+        "orm",
+        "zuz",
+        "zuz.js",
+        "zuz orm",
+        "zuzjs"
+    ],
+    "description": "ZuzJS ORM Library",
+    "author": "Zuz.js Team <support@zuz.com.pk>",
+    "license": "MIT",
+    "type": "commonjs",
+    "main": "dist/index.js",
+    "bin": {
+        "zorm": "dist/bin.js"
+    },
+    "exports": {
+        ".": "./dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "dev": "tsc -d -w -p tsconfig.json"
+    },
+    "engines": {
+        "node": ">=18.17.0"
+    },
+    "dependencies": {
+        "@types/md5": "^2.3.5",
+        "commander": "^13.1.0",
+        "md5": "^2.3.0",
+        "mysql2": "^3.12.0",
+        "nanoid": "^5.1.0",
+        "picocolors": "^1.1.1",
+        "reflect-metadata": "^0.2.2",
+        "typeorm": "^0.3.20"
+    },
+    "devDependencies": {
+        "husky": "^9.1.7",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.7.3"
+    },
+    "peerDependencies": {
+        "reflect-metadata": "^0.2.2",
+        "typeorm": "^0.3.0"
+    }
+}