@zuzjs/orm 0.1.1 → 0.1.3

package/dist/bin.js

@@ -4,36 +4,23 @@ 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");
+const cli_js_1 = require("./core/cli.js");
+const picocolors_1 = __importDefault(require("picocolors"));
+commander_1.program
+    .name("zorm")
+    .description("ZuzORM is a lightweight ORM wrapper around TypeORM with support for MySQL.");
+/**Version */
 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`);
+    .description("Displays current version of ZuzORM")
+    .action(() => {
+    const packageJson = require("../package.json");
+    console.log(picocolors_1.default.cyan(`ZuzORM v${packageJson.version}`));
     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);
-    }
-}
+});
+commander_1.program
+    .command(`pull`)
+    .description(`Pull using DATABASE_URL from .env in project directory`)
+    .action(cli_js_1.Pull);
+commander_1.program.parse();

package/dist/core/cli.d.ts

@@ -0,0 +1,5 @@
+export declare const buildEntities: (connection: string, dist?: string) => void;
+/**
+* Pull using DATABASE_URL from .env in project directory
+**/
+export declare const Pull: () => void;

package/dist/core/cli.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pull = exports.buildEntities = void 0;
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const index_js_1 = require("./index.js");
+const mysql_1 = require("../drivers/mysql");
+const buildEntities = (connection, dist) => {
+    dist = dist || path_1.default.join(`src`, `zorm`);
+    const _checkDist = (0, index_js_1.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 mysql_1.MySqlDriver(decodeURIComponent(connection), dist);
+        driver.generate();
+    }
+    else {
+        console.log(`○ Only MySQL is supported for now`);
+        process.exit(1);
+    }
+};
+exports.buildEntities = buildEntities;
+/**
+* Pull using DATABASE_URL from .env in project directory
+**/
+const Pull = () => {
+    const env = path_1.default.join(process.cwd(), `.env`);
+    if (!(0, fs_1.existsSync)(env)) {
+        console.log(picocolors_1.default.red(`○ ".env" not exists. Create .env and add DATABASE_URL="connection_string"`));
+        return;
+    }
+    const raw = fs_1.default.readFileSync(env, `utf8`).split(`\n`).filter((line) => line.startsWith(`DATABASE_URL`));
+    if (raw.length == 0) {
+        console.log(picocolors_1.default.red(`○ DATABASE_URL not found in ".env". Add DATABASE_URL="connection_string"`));
+        return;
+    }
+    (0, exports.buildEntities)(raw[0].trim().replace(/DATABASE_URL=|"|"/g, ``));
+};
+exports.Pull = Pull;

package/dist/drivers/mysql/index.js

@@ -144,10 +144,15 @@ class MySqlDriver {
             // Get table structure
             const [columns] = await self.pool.execute(`DESCRIBE ${tableName}`);
             const entityCode = [
-                `import { Entity, PrimaryColumn, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm";\n`,
+                `/**`,
+                `* AutoGenerated by @zuzjs/orm.`,
+                `* @ ${new Date().toString().split(` GMT`)[0].trim()}`,
+                `*/`,
+                `import { Entity, PrimaryColumn, PrimaryGeneratedColumn, Column, BaseEntity } from "@zuzjs/orm";\n`,
                 `@Entity({ name: "${tableName}" })`,
                 `export class ${(0, index_js_1.toPascalCase)(tableName)} extends BaseEntity {\n`
             ];
+            let hasPrimary = false;
             for (const column of columns) {
                 // const { Field, Type, Key } = column;
                 const { Field, Type, Key, Null, Default, Extra } = column;
@@ -155,6 +160,7 @@ class MySqlDriver {
                 // Handle primary key
                 if (Key === "PRI") {
                     entityCode.push(Extra.includes("auto_increment") ? `\t@PrimaryGeneratedColumn()` : `\t@PrimaryColumn()`);
+                    hasPrimary = true;
                 }
                 else {
                     let columnDecorator = `\t@Column({ type: "${columnType}"`;
@@ -170,12 +176,14 @@ class MySqlDriver {
                 entityCode.push(`\t${Field}!: ${tsType};\n`);
             }
             entityCode.push(`}`);
+            if (!hasPrimary) {
+                console.log(picocolors_1.default.bgRed(picocolors_1.default.whiteBright(` WARNING `)), picocolors_1.default.yellow(`○ "${tableName}" does not have a primary column. Primary column is required.`));
+            }
             // 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

@@ -16,27 +16,118 @@ declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends
     _update(): this;
     _delete(): this;
     _getRawQuery(): [string, any[]];
+    /**
+     * Sets the values for an insert or update query.
+     * @param data - The data to be inserted or updated.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     with(data: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T[]>): this;
+    /**
+     * Specifies the fields to be selected in a select query.
+     * @param fields - The fields to be selected.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     select(fields: (keyof T)[]): this;
-    where(condition: FindOptionsWhere<T>): this;
+    /**
+     * Adds a WHERE condition to the query.
+     * @param condition - The condition to be added.
+     * @returns The current instance of ZormQueryBuilder.
+     */
+    where(condition: Partial<Record<keyof T, any>>): this;
+    /**
+     * Adds an OR condition to the query.
+     * @param condition - The condition to be added.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     or(condition: FindOptionsWhere<T>): this;
+    /**
+     * Adds an ORDER BY clause to the query.
+     * @param field - The field to order by.
+     * @param direction - The direction of the order (ASC or DESC).
+     * @returns The current instance of ZormQueryBuilder.
+     */
     orderBy(field: keyof T, direction?: "ASC" | "DESC"): this;
+    /**
+     * Adds a LIMIT clause to the query.
+     * @param n - The maximum number of records to return.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     limit(n: number): this;
+    /**
+     * Adds an OFFSET clause to the query.
+     * @param n - The number of records to skip.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     offset(n: number): this;
+    /**
+     * Adds relations to be included in the query.
+     * @param relations - The relations to be included.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     relations(relations: string[]): this;
+    /**
+     * Adds an INNER JOIN clause to the query.
+     * @param relation - The relation to join.
+     * @param alias - The alias for the joined relation.
+     * @param condition - Optional condition for the join.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     innerJoin(relation: string, alias: string, condition?: string): this;
+    /**
+     * Adds a LEFT JOIN clause to the query.
+     * @param relation - The relation to join.
+     * @param alias - The alias for the joined relation.
+     * @param condition - Optional condition for the join.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     leftJoin(relation: string, alias: string, condition?: string): this;
+    /**
+     * Adds a GROUP BY clause to the query.
+     * @param field - The field to group by.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     groupBy(field: keyof T): this;
+    /**
+     * Adds a HAVING clause to the query.
+     * @param condition - The condition for the HAVING clause.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     having(condition: string): this;
+    /**
+     * Adds an IN clause to the query.
+     * @param field - The field to check.
+     * @param values - The values for the IN clause.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     in(field: keyof T, values: any[]): this;
+    /**
+     * Adds a DISTINCT clause to the query.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     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>;
+    /**
+     * Executes a raw SQL query.
+     * @param sql - The raw SQL query.
+     * @param params - Optional parameters for the query.
+     * @returns A promise that resolves with the query result.
+     */
     rawQuery(sql: string, params?: any): Promise<any>;
+    /**
+     * Executes the query and returns the result.
+     * @returns A promise that resolves with the query result.
+     */
     execute(): Promise<R>;
+    /**
+     * Handles the fulfillment and rejection of the promise.
+     * @param onfulfilled - The callback to execute when the promise is fulfilled.
+     * @param onrejected - The callback to execute when the promise is rejected.
+     * @returns A promise that resolves with the result of the callback.
+     */
     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

@@ -63,40 +63,104 @@ class ZormQueryBuilder extends Promise {
     _getRawQuery() {
         return this.queryBuilder.getQueryAndParameters();
     }
+    /**
+     * Sets the values for an insert or update query.
+     * @param data - The data to be inserted or updated.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     with(data) {
         this.queryValues = data;
         return this;
     }
+    /**
+     * Specifies the fields to be selected in a select query.
+     * @param fields - The fields to be selected.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     select(fields) {
         this.queryBuilder
             .select(fields.map(field => `${this.entityAlias}.${String(field)}`));
         return this;
     }
+    /**
+     * Adds a WHERE condition to the query.
+     * @param condition - The condition to be added.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     where(condition) {
-        this.queryBuilder.where(condition);
+        const qb = this.queryBuilder;
+        Object.entries(condition).forEach(([key, value]) => {
+            if (typeof value === "string" && value.startsWith("!")) {
+                qb.andWhere(`${this.entityAlias}.${key} != :${key}`, { [key]: value.slice(1) });
+            }
+            else if (typeof value === "boolean" || typeof value === "number") {
+                qb.andWhere(`${this.entityAlias}.${key} = :${key}`, { [key]: value });
+            }
+            else {
+                qb.andWhere(`${this.entityAlias}.${key} = :${key}`, { [key]: value });
+            }
+        });
         this.whereCount++;
         return this;
     }
+    // where(condition: FindOptionsWhere<T>): this {
+    //     (this.queryBuilder as  SelectQueryBuilder<T> | UpdateQueryBuilder<T>).where(condition);
+    //     this.whereCount++
+    //     return this;
+    // }
+    /**
+     * Adds an OR condition to the query.
+     * @param condition - The condition to be added.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     or(condition) {
         this.queryBuilder.orWhere(condition);
         return this;
     }
+    /**
+     * Adds an ORDER BY clause to the query.
+     * @param field - The field to order by.
+     * @param direction - The direction of the order (ASC or DESC).
+     * @returns The current instance of ZormQueryBuilder.
+     */
     orderBy(field, direction = "ASC") {
         this.queryBuilder.orderBy(`${this.entityAlias}.${String(field)}`, direction);
         return this;
     }
+    /**
+     * Adds a LIMIT clause to the query.
+     * @param n - The maximum number of records to return.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     limit(n) {
         this.queryBuilder.limit(n);
         return this;
     }
+    /**
+     * Adds an OFFSET clause to the query.
+     * @param n - The number of records to skip.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     offset(n) {
         this.queryBuilder.offset(n);
         return this;
     }
+    /**
+     * Adds relations to be included in the query.
+     * @param relations - The relations to be included.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     relations(relations) {
         relations.forEach(relation => this.queryBuilder.leftJoinAndSelect(`${this.entityAlias}.${relation}`, relation));
         return this;
     }
+    /**
+     * Adds an INNER JOIN clause to the query.
+     * @param relation - The relation to join.
+     * @param alias - The alias for the joined relation.
+     * @param condition - Optional condition for the join.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     innerJoin(relation, alias, condition) {
         if (condition) {
             this.queryBuilder.innerJoin(`${this.entityAlias}.${relation}`, alias, condition);
@@ -106,6 +170,13 @@ class ZormQueryBuilder extends Promise {
         }
         return this;
     }
+    /**
+     * Adds a LEFT JOIN clause to the query.
+     * @param relation - The relation to join.
+     * @param alias - The alias for the joined relation.
+     * @param condition - Optional condition for the join.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     leftJoin(relation, alias, condition) {
         if (condition) {
             this.queryBuilder.leftJoin(`${this.entityAlias}.${relation}`, alias, condition);
@@ -115,18 +186,38 @@ class ZormQueryBuilder extends Promise {
         }
         return this;
     }
+    /**
+     * Adds a GROUP BY clause to the query.
+     * @param field - The field to group by.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     groupBy(field) {
         this.queryBuilder.groupBy(`${this.entityAlias}.${String(field)}`);
         return this;
     }
+    /**
+     * Adds a HAVING clause to the query.
+     * @param condition - The condition for the HAVING clause.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     having(condition) {
         this.queryBuilder.having(condition);
         return this;
     }
+    /**
+     * Adds an IN clause to the query.
+     * @param field - The field to check.
+     * @param values - The values for the IN clause.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     in(field, values) {
         this.queryBuilder.andWhere(`${this.entityAlias}.${String(field)} IN (:...values)`, { values });
         return this;
     }
+    /**
+     * Adds a DISTINCT clause to the query.
+     * @returns The current instance of ZormQueryBuilder.
+     */
     distinct() {
         this.queryBuilder.distinct(true);
         return this;
@@ -150,10 +241,27 @@ class ZormQueryBuilder extends Promise {
         const result = await this.queryBuilder.select(`MAX(${this.entityAlias}.${String(field)})`, "max").getRawOne();
         return result.max || 0;
     }
+    /**
+     * Executes a raw SQL query.
+     * @param sql - The raw SQL query.
+     * @param params - Optional parameters for the query.
+     * @returns A promise that resolves with the query result.
+     */
     async rawQuery(sql, params) {
         return await this.repository.query(sql, params);
     }
+    /**
+     * Executes the query and returns the result.
+     * @returns A promise that resolves with the query result.
+     */
     async execute() {
+        const removedMethods = {};
+        Object.keys(Object.prototype).forEach((method) => {
+            if (Object.prototype.hasOwnProperty.call(Object.prototype, method)) {
+                removedMethods[method] = Object.prototype[method];
+                delete Object.prototype[method];
+            }
+        });
         try {
             switch (this.action) {
                 case "upsert":
@@ -169,9 +277,18 @@ class ZormQueryBuilder extends Promise {
                     };
                 case "update":
                     this._update();
-                    const _update = await this.queryBuilder.execute();
-                    // console.log(`updated`, _update)
-                    return { updated: true };
+                    const _updateQuery = this.queryBuilder;
+                    const _update = await _updateQuery.execute();
+                    const whereQuery = _updateQuery.getQuery().split("WHERE")[1]?.trim(); // Get the WHERE clause
+                    const _get = this.repository
+                        .createQueryBuilder(this.entityAlias)
+                        .where(whereQuery, _updateQuery.getParameters()); // Use the same parameters
+                    const _updated = await _get.getMany();
+                    return {
+                        updated: true,
+                        record: _updated[0],
+                        records: _updated.length > 1 ? _updated : null
+                    };
                 case "delete":
                     this._delete();
                     const _delete = await this.queryBuilder.execute();
@@ -180,9 +297,9 @@ class ZormQueryBuilder extends Promise {
                 default:
                     const _select = await this.queryBuilder.getMany();
                     return {
-                        hasRows: true,
+                        hasRows: _select.length > 0,
                         count: _select.length,
-                        row: _select[0],
+                        row: _select.length > 0 ? _select[0] : null,
                         rows: _select
                     };
             }
@@ -216,7 +333,18 @@ class ZormQueryBuilder extends Promise {
                     return this.usePromise ? Promise.reject(_s) : _s;
             }
         }
+        finally {
+            Object.entries(removedMethods).forEach(([method, fn]) => {
+                Object.prototype[method] = fn;
+            });
+        }
     }
+    /**
+     * Handles the fulfillment and rejection of the promise.
+     * @param onfulfilled - The callback to execute when the promise is fulfilled.
+     * @param onrejected - The callback to execute when the promise is rejected.
+     * @returns A promise that resolves with the result of the callback.
+     */
     then(onfulfilled, onrejected) {
         return this.execute().then(onfulfilled, onrejected);
     }

package/dist/index.d.ts

@@ -1,25 +1,91 @@
 import { EntitySchema, EntityTarget, MixedList, ObjectLiteral, Repository } from "typeorm";
 import ZormQueryBuilder from "./drivers/queryBuilder.js";
 import { InsertQueryResult, SelectQueryResult, UpdateQueryResult } from "./types.js";
+import "reflect-metadata";
+/**
+ * Zorm is a lightweight ORM wrapper around TypeORM with support for MySQL.
+ */
 declare class Zorm {
+    /**
+     * Singleton instance of Zorm.
+     * @private
+     */
     private static instance;
+    /**
+     * TypeORM DataSource instance.
+     * @private
+     */
     private dataSource;
+    /**
+     * Flag to track if the connection is initialized.
+     * @private
+     */
     private initialized;
+    /**
+     * Determines whether to use Promises for queries.
+     * @private
+     */
     private usePromise;
+    /**
+     * Private constructor to enforce singleton pattern.
+     * @param {string} connectionString - The database connection string.
+     * @param {string | null} [entitiesPath] - Path to the entities directory.
+     * @param {boolean} [usePromise] - Whether to use Promises for queries.
+     * @private
+     */
     private constructor();
+    /**
+     * Returns the singleton instance of Zorm.
+     * @param {string} connectionString - The database connection string.
+     * @param {string | null} [entitiesPath] - Path to the entities directory.
+     * @param {boolean} [usePromise] - Whether to use Promises for queries.
+     * @returns {Zorm} The singleton instance of Zorm.
+     */
     static get(connectionString: string, entitiesPath?: string | null, usePromise?: boolean): Zorm;
+    /**
+     * Connects to the database and initializes entities.
+     * @param {MixedList<string | Function | EntitySchema<any>>} entities - List of entity schemas.
+     * @returns {Promise<void>} Resolves when the connection is initialized.
+     */
     connect(entities: MixedList<string | Function | EntitySchema<any>>): Promise<void>;
     /**
      * Returns the appropriate QueryBuilder based on the database type.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @param {QueryAction} action - The query action type.
+     * @returns {ZormQueryBuilder<T, R>} Query builder instance.
+     * @private
      */
     private getQueryBuilder;
     /**
-     * Get a repository for a specific entity
+     * Retrieves the repository for a given entity.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {Repository<T>} The repository instance.
      */
     getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
+    /**
+     * Creates a new record in the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, InsertQueryResult>} The query builder instance.
+     */
     create<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, InsertQueryResult>;
+    /**
+     * Finds records in the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, SelectQueryResult>} The query builder instance.
+     */
     find<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, SelectQueryResult>;
+    /**
+     * Updates records in the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, UpdateQueryResult>} The query builder instance.
+     */
     update<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, UpdateQueryResult>;
+    /**
+     * Deletes records from the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, DeleteQueryResult>} The query builder instance.
+     */
     delete<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, UpdateQueryResult>;
 }
 export default Zorm;
+export * from "./types.js";

package/dist/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,11 +23,38 @@ 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"));
+require("reflect-metadata");
+/**
+ * Zorm is a lightweight ORM wrapper around TypeORM with support for MySQL.
+ */
 class Zorm {
+    /**
+     * Singleton instance of Zorm.
+     * @private
+     */
     static instance;
+    /**
+     * TypeORM DataSource instance.
+     * @private
+     */
     dataSource;
+    /**
+     * Flag to track if the connection is initialized.
+     * @private
+     */
     initialized = false;
+    /**
+     * Determines whether to use Promises for queries.
+     * @private
+     */
     usePromise = false;
+    /**
+     * Private constructor to enforce singleton pattern.
+     * @param {string} connectionString - The database connection string.
+     * @param {string | null} [entitiesPath] - Path to the entities directory.
+     * @param {boolean} [usePromise] - Whether to use Promises for queries.
+     * @private
+     */
     constructor(connectionString, entitiesPath, usePromise) {
         const _dist = entitiesPath || path_1.default.join(`src`, `zorm`);
         const dist = path_1.default.join(process.cwd(), _dist);
@@ -40,12 +81,24 @@ class Zorm {
             process.exit(1);
         }
     }
+    /**
+     * Returns the singleton instance of Zorm.
+     * @param {string} connectionString - The database connection string.
+     * @param {string | null} [entitiesPath] - Path to the entities directory.
+     * @param {boolean} [usePromise] - Whether to use Promises for queries.
+     * @returns {Zorm} The singleton instance of Zorm.
+     */
     static get(connectionString, entitiesPath, usePromise) {
         if (!Zorm.instance) {
             Zorm.instance = new Zorm(connectionString, entitiesPath, usePromise);
         }
         return Zorm.instance;
     }
+    /**
+     * Connects to the database and initializes entities.
+     * @param {MixedList<string | Function | EntitySchema<any>>} entities - List of entity schemas.
+     * @returns {Promise<void>} Resolves when the connection is initialized.
+     */
     async connect(entities) {
         if (!this.initialized) {
             try {
@@ -61,6 +114,10 @@ class Zorm {
     }
     /**
      * Returns the appropriate QueryBuilder based on the database type.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @param {QueryAction} action - The query action type.
+     * @returns {ZormQueryBuilder<T, R>} Query builder instance.
+     * @private
      */
     getQueryBuilder(entity, action) {
         const repository = this.getRepository(entity);
@@ -79,25 +136,48 @@ class Zorm {
         }
     }
     /**
-     * Get a repository for a specific entity
+     * Retrieves the repository for a given entity.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {Repository<T>} The repository instance.
      */
     getRepository(entity) {
         return this.dataSource.getRepository(entity);
     }
+    /**
+     * Creates a new record in the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, InsertQueryResult>} The query builder instance.
+     */
     create(entity) {
         return this.getQueryBuilder(entity, "create");
     }
+    /**
+     * Finds records in the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, SelectQueryResult>} The query builder instance.
+     */
     find(entity) {
         return this.getQueryBuilder(entity, "select");
     }
     // upsert<T extends ObjectLiteral>(entity: EntityTarget<T>): ZormQueryBuilder<T, InsertQueryResult> {
     //     return this.getQueryBuilder(entity, "upsert");
     // }
+    /**
+     * Updates records in the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, UpdateQueryResult>} The query builder instance.
+     */
     update(entity) {
         return this.getQueryBuilder(entity, "update");
     }
+    /**
+     * Deletes records from the database.
+     * @param {EntityTarget<T>} entity - The entity target.
+     * @returns {ZormQueryBuilder<T, DeleteQueryResult>} The query builder instance.
+     */
     delete(entity) {
         return this.getQueryBuilder(entity, "delete");
     }
 }
 exports.default = Zorm;
+__exportStar(require("./types.js"), exports);

package/dist/types.d.ts

@@ -39,6 +39,8 @@ export type SelectQueryResult = {
 };
 export type UpdateQueryResult = {
     updated: boolean;
+    record?: ObjectLiteral;
+    records?: ObjectLiteral[];
     error?: QueryError;
 };
 export type DeleteQueryResult = {
@@ -46,3 +48,4 @@ export type DeleteQueryResult = {
     count: number;
     error?: QueryError;
 };
+export { Entity, PrimaryColumn, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm";

package/dist/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntity = exports.Column = exports.PrimaryGeneratedColumn = exports.PrimaryColumn = exports.Entity = void 0;
+var typeorm_1 = require("typeorm");
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return typeorm_1.Entity; } });
+Object.defineProperty(exports, "PrimaryColumn", { enumerable: true, get: function () { return typeorm_1.PrimaryColumn; } });
+Object.defineProperty(exports, "PrimaryGeneratedColumn", { enumerable: true, get: function () { return typeorm_1.PrimaryGeneratedColumn; } });
+Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return typeorm_1.Column; } });
+Object.defineProperty(exports, "BaseEntity", { enumerable: true, get: function () { return typeorm_1.BaseEntity; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zuzjs/orm",
-    "version": "0.1.1",
+    "version": "0.1.3",
     "keywords": [
         "orm",
         "zuz",
@@ -28,6 +28,7 @@
     "engines": {
         "node": ">=18.17.0"
     },
+    "sideEffects": ["reflect-metadata"],
     "dependencies": {
         "@types/md5": "^2.3.5",
         "commander": "^13.1.0",