@cheetah.js/orm 0.1.136 → 0.1.141

package/README.md

@@ -39,6 +39,7 @@ export default config;
 Actually, the ORM only supports PostgreSQL, but in the future it will support other databases.
 - Entities: Path to entities. Accepts glob patterns or an array of Entity classes.
 - MigrationPath: Path to migrations. Accepts glob patterns. Is optional.
+- Connection pool (optional): `max`, `idleTimeout`, `maxLifetime`, `connectionTimeout` in seconds control the Bun SQL pool. Defaults are 20 connections, 20s idle timeout, 300s max lifetime, and 10s connection timeout.
 <br/>
 <br/>
 After that, you need to import the ORM into the project and add it to the Cheetah.js instance:

package/dist/driver/bun-driver.base.d.ts

@@ -1,14 +1,27 @@
-import { SQL } from 'bun';
-import { ConnectionSettings, DriverInterface, Statement, SnapshotConstraintInfo, ColDiff } from './driver.interface';
+import { SQL } from "bun";
+import { ConnectionSettings, DriverInterface, Statement, SnapshotConstraintInfo, ColDiff } from "./driver.interface";
 export declare abstract class BunDriverBase implements Partial<DriverInterface> {
     protected sql: SQL;
     connectionString: string;
-    abstract readonly dbType: 'postgres' | 'mysql';
+    protected readonly poolOptions: {
+        max: number;
+        idleTimeout: number;
+        maxLifetime: number;
+        connectionTimeout: number;
+    };
+    abstract readonly dbType: "postgres" | "mysql";
     constructor(options: ConnectionSettings);
     protected buildConnectionString(options: ConnectionSettings): string;
     protected abstract getProtocol(): string;
     protected abstract getIdentifierQuote(): string;
     connect(): Promise<void>;
+    protected buildPoolOptions(options: ConnectionSettings): {
+        max: number;
+        idleTimeout: number;
+        maxLifetime: number;
+        connectionTimeout: number;
+    };
+    private createSqlInstance;
     protected validateConnection(): Promise<void>;
     disconnect(): Promise<void>;
     executeSql(sqlString: string): Promise<any>;

package/dist/driver/bun-driver.base.js

@@ -6,6 +6,7 @@ const transaction_context_1 = require("../transaction/transaction-context");
 class BunDriverBase {
     constructor(options) {
         this.connectionString = this.buildConnectionString(options);
+        this.poolOptions = this.buildPoolOptions(options);
     }
     buildConnectionString(options) {
         if (options.connectionString) {
@@ -19,23 +20,35 @@ class BunDriverBase {
         if (this.sql) {
             return;
         }
-        this.sql = new bun_1.SQL({
+        this.sql = this.createSqlInstance();
+        await this.validateConnection();
+    }
+    buildPoolOptions(options) {
+        return {
+            max: options.max ?? undefined,
+            idleTimeout: options.idleTimeout ?? undefined,
+            maxLifetime: options.maxLifetime ?? undefined,
+            connectionTimeout: options.connectionTimeout ?? undefined,
+        };
+    }
+    createSqlInstance() {
+        return new bun_1.SQL({
             url: this.connectionString,
-            max: 20,
-            idleTimeout: 20, // segundos antes de fechar idle
-            maxLifetime: 300, // recicla conexões a cada 5 min
-            connectionTimeout: 10
+            max: this.poolOptions.max,
+            idleTimeout: this.poolOptions.idleTimeout,
+            maxLifetime: this.poolOptions.maxLifetime,
+            connectionTimeout: this.poolOptions.connectionTimeout,
         });
-        await this.validateConnection();
     }
     async validateConnection() {
-        await this.sql.unsafe('SELECT 1');
+        await this.sql.unsafe("SELECT 1");
     }
     async disconnect() {
         if (!this.sql) {
             return;
         }
         await this.sql.close();
+        this.sql = null;
     }
     async executeSql(sqlString) {
         const context = this.getExecutionContext();
@@ -47,31 +60,31 @@ class BunDriverBase {
             return txContext;
         }
         if (!this.sql) {
-            throw new Error('Database not connected');
+            throw new Error("Database not connected");
         }
         return this.sql;
     }
     async transaction(callback) {
         if (!this.sql) {
-            throw new Error('Database not connected');
+            throw new Error("Database not connected");
         }
         return await this.sql.begin(callback);
     }
     toDatabaseValue(value) {
         if (value === null || value === undefined) {
-            return 'NULL';
+            return "NULL";
         }
         if (value instanceof Date) {
             return `'${value.toISOString()}'`;
         }
         switch (typeof value) {
-            case 'string':
+            case "string":
                 return `'${this.escapeString(value)}'`;
-            case 'number':
+            case "number":
                 return value;
-            case 'boolean':
+            case "boolean":
                 return value;
-            case 'object':
+            case "object":
                 return `'${this.escapeString(JSON.stringify(value))}'`;
             default:
                 return `'${this.escapeString(String(value))}'`;
@@ -85,25 +98,25 @@ class BunDriverBase {
     }
     buildWhereClause(where) {
         if (!where) {
-            return '';
+            return "";
         }
         return ` WHERE ${where}`;
     }
     buildOrderByClause(orderBy) {
         if (!orderBy || orderBy.length === 0) {
-            return '';
+            return "";
         }
-        return ` ORDER BY ${orderBy.join(', ')}`;
+        return ` ORDER BY ${orderBy.join(", ")}`;
     }
     buildLimitClause(limit) {
         if (!limit) {
-            return '';
+            return "";
         }
         return ` LIMIT ${limit}`;
     }
     buildOffsetClause(offset) {
         if (!offset) {
-            return '';
+            return "";
         }
         return ` OFFSET ${offset}`;
     }
@@ -119,23 +132,23 @@ class BunDriverBase {
     buildColumnConstraints(colDiff) {
         const parts = [];
         if (!colDiff.colChanges?.nullable) {
-            parts.push('NOT NULL');
+            parts.push("NOT NULL");
         }
         if (colDiff.colChanges?.primary) {
-            parts.push('PRIMARY KEY');
+            parts.push("PRIMARY KEY");
         }
         if (colDiff.colChanges?.unique) {
-            parts.push('UNIQUE');
+            parts.push("UNIQUE");
         }
         if (colDiff.colChanges?.default) {
             parts.push(`DEFAULT ${colDiff.colChanges.default}`);
         }
-        return parts.length > 0 ? ' ' + parts.join(' ') : '';
+        return parts.length > 0 ? " " + parts.join(" ") : "";
     }
     async executeStatement(statement) {
         const startTime = Date.now();
         const context = this.getExecutionContext();
-        if (statement.statement === 'insert') {
+        if (statement.statement === "insert") {
             const sql = this.buildInsertSqlWithReturn(statement);
             const result = await context.unsafe(sql);
             return this.handleInsertReturn(statement, result, sql, startTime);
@@ -161,34 +174,34 @@ class BunDriverBase {
     buildBaseSql(statement) {
         const { statement: type, table, columns, values, alias } = statement;
         switch (type) {
-            case 'select':
-                return `SELECT ${columns ? columns.join(', ') : '*'} FROM ${table} ${alias}`;
-            case 'insert':
+            case "select":
+                return `SELECT ${columns ? columns.join(", ") : "*"} FROM ${table} ${alias}`;
+            case "insert":
                 return this.buildInsertSql(table, values, columns, alias);
-            case 'update':
+            case "update":
                 return this.buildUpdateSql(table, values, alias);
-            case 'delete':
+            case "delete":
                 return this.buildDeleteSql(table, alias);
-            case 'count':
+            case "count":
                 return `SELECT COUNT(*) as count FROM ${table} ${alias}`;
             default:
-                return '';
+                return "";
         }
     }
     buildInsertSql(table, values, columns, alias) {
         const q = this.getIdentifierQuote();
         const fields = Object.keys(values)
             .map((v) => `${q}${v}${q}`)
-            .join(', ');
+            .join(", ");
         const vals = Object.values(values)
             .map((value) => this.toDatabaseValue(value))
-            .join(', ');
+            .join(", ");
         return `INSERT INTO ${table} (${fields}) VALUES (${vals})`;
     }
     buildUpdateSql(table, values, alias) {
         const sets = Object.entries(values)
             .map(([key, value]) => `${key} = ${this.toDatabaseValue(value)}`)
-            .join(', ');
+            .join(", ");
         return `UPDATE ${table} as ${alias} SET ${sets}`;
     }
     buildDeleteSql(table, alias) {
@@ -196,17 +209,17 @@ class BunDriverBase {
     }
     buildJoinClause(statement) {
         if (!statement.join)
-            return '';
+            return "";
         return statement.join
             .map((join) => {
             const table = `${join.joinSchema}.${join.joinTable}`;
             return ` ${join.type} JOIN ${table} ${join.joinAlias} ON ${join.on}`;
         })
-            .join('');
+            .join("");
     }
     buildWhereAndOrderClauses(statement) {
-        if (statement.statement === 'insert')
-            return '';
+        if (statement.statement === "insert")
+            return "";
         let sql = this.buildWhereClause(statement.where);
         sql += this.buildOrderByClause(statement.orderBy);
         sql += this.buildLimitAndOffsetClause(statement);
@@ -220,7 +233,7 @@ class BunDriverBase {
         if (limit) {
             return this.buildLimitClause(limit);
         }
-        return '';
+        return "";
     }
     getForeignKeysFromConstraints(constraints, row, columnNameField) {
         const columnName = row[columnNameField];
@@ -230,25 +243,28 @@ class BunDriverBase {
             .filter(Boolean);
     }
     isForeignKeyConstraint(constraint, columnName) {
-        return (constraint.type === 'FOREIGN KEY' &&
+        return (constraint.type === "FOREIGN KEY" &&
             constraint.consDef.includes(columnName));
     }
     parseForeignKeyDefinition(consDef) {
         const quote = this.getIdentifierQuote();
         const escapedQuote = this.escapeRegex(quote);
-        const pattern = new RegExp(`REFERENCES\\s+(?:${escapedQuote}([^${escapedQuote}]+)${escapedQuote}|([\\w.]+))\\s*\\(([^)]+)\\)`, 'i');
+        const pattern = new RegExp(`REFERENCES\\s+(?:${escapedQuote}([^${escapedQuote}]+)${escapedQuote}|([\\w.]+))\\s*\\(([^)]+)\\)`, "i");
         const match = consDef.match(pattern);
         if (!match)
             return null;
         const tableName = (match[1] || match[2]).trim();
-        const columnName = match[3].split(',')[0].trim().replace(new RegExp(escapedQuote, 'g'), '');
+        const columnName = match[3]
+            .split(",")[0]
+            .trim()
+            .replace(new RegExp(escapedQuote, "g"), "");
         return {
             referencedColumnName: columnName,
-            referencedTableName: tableName
+            referencedTableName: tableName,
         };
     }
     escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
 }
 exports.BunDriverBase = BunDriverBase;

package/dist/driver/driver.interface.d.ts

@@ -1,10 +1,10 @@
-import { PropertyOptions } from '../decorators/property.decorator';
-import { Collection } from '../domain/collection';
-import { Reference } from '../domain/reference';
-import { ValueObject } from '../common/value-object';
+import { PropertyOptions } from "../decorators/property.decorator";
+import { Collection } from "../domain/collection";
+import { Reference } from "../domain/reference";
+import { ValueObject } from "../common/value-object";
 export interface DriverInterface {
     connectionString: string;
-    readonly dbType: 'postgres' | 'mysql';
+    readonly dbType: "postgres" | "mysql";
     executeStatement(statement: Statement<any>): Promise<{
         query: any;
         startTime: number;
@@ -41,7 +41,8 @@ export interface DriverInterface {
     }, schema: string | undefined, tableName: string): string;
     transaction<T>(callback: (tx: any) => Promise<T>): Promise<T>;
 }
-export type ValueOrInstance<T> = T extends ValueObject<any, any> ? T | T['value'] : NonNullable<T>;
+export type ValueOrInstance<T> = T extends ValueObject<any, any> ? // @ts-ignore
+T | T["value"] : NonNullable<T>;
 export type SnapshotConstraintInfo = {
     indexName: string;
     consDef: string;
@@ -54,6 +55,10 @@ export interface ConnectionSettings<T extends DriverInterface = DriverInterface>
     password?: string;
     database?: string;
     connectionString?: string;
+    max?: number;
+    idleTimeout?: number;
+    maxLifetime?: number;
+    connectionTimeout?: number;
     ssl?: boolean;
     driver: new (options: ConnectionSettings<T>) => T;
     entities?: Function[] | string;
@@ -85,7 +90,7 @@ export interface EnumOptions<T> extends PropertyOptions {
     array?: boolean;
 }
 export type JoinStatement<T> = {
-    type: 'INNER' | 'LEFT' | 'RIGHT';
+    type: "INNER" | "LEFT" | "RIGHT";
     originalEntity?: Function;
     originTable: string;
     originSchema: string;
@@ -104,14 +109,14 @@ export type JoinStatement<T> = {
     }[];
 };
 export type Statement<T> = {
-    statement?: 'select' | 'insert' | 'update' | 'delete' | 'count';
+    statement?: "select" | "insert" | "update" | "delete" | "count";
     table?: string;
     alias?: string;
     customSchema?: string;
     columns?: string[];
     join?: JoinStatement<T>[];
     selectJoin?: Statement<T>[];
-    strategy?: 'select' | 'joined';
+    strategy?: "select" | "joined";
     where?: string;
     values?: any;
     groupBy?: string[];
@@ -161,10 +166,10 @@ export type ColumnsInfo = {
     precision?: number;
     scale?: number;
     isDecimal?: boolean;
-    enumItems?: string[] | number[] | '__AUTO_DETECT__';
+    enumItems?: string[] | number[] | "__AUTO_DETECT__";
     foreignKeys?: ForeignKeyInfo[];
 };
-export type SqlActionType = 'CREATE' | 'DELETE' | 'ALTER' | 'INDEX';
+export type SqlActionType = "CREATE" | "DELETE" | "ALTER" | "INDEX";
 export type ColDiff = {
     actionType: SqlActionType;
     colName: string;
@@ -209,11 +214,11 @@ export type PrimaryProperty<T> = T extends {
     [PrimaryKeyProp]?: infer PK;
 } ? PK : T extends {
     _id?: any;
-} ? '_id' | string : T extends {
+} ? "_id" | string : T extends {
     uuid?: any;
-} ? 'uuid' : T extends {
+} ? "uuid" : T extends {
     id?: any;
-} ? 'id' : never;
+} ? "id" : never;
 export type IPrimaryKeyValue = number | string | bigint | Date | {
     toHexString(): string;
 };
@@ -232,7 +237,7 @@ export type OperatorMap<T> = {
     $lte?: ExpandScalar<T>;
     $like?: string;
 };
-export type ExcludeFunctions<T, K extends keyof T> = T[K] extends Function ? never : (K extends symbol ? never : K);
+export type ExcludeFunctions<T, K extends keyof T> = T[K] extends Function ? never : K extends symbol ? never : K;
 export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | {
     toHexString(): string;
 };
@@ -257,7 +262,7 @@ export type ObjectQuery<T> = ExpandObject<T> & OperatorMap<T>;
 export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
 export type Relationship<T> = {
     isRelation?: boolean;
-    relation: 'one-to-many' | 'many-to-one';
+    relation: "one-to-many" | "many-to-one";
     type: Function;
     fkKey?: (string & keyof T) | ((e: T) => any);
     entity: () => EntityName<T>;
@@ -271,7 +276,7 @@ type Loadable<T extends object> = Collection<T, any> | Reference<T> | readonly T
 type ExtractType<T> = T extends Loadable<infer U> ? U : T;
 type StringKeys<T, E extends string = never> = T extends Collection<any, any> ? `${Exclude<keyof ExtractType<T> | E, symbol>}` : T extends Reference<any> ? `${Exclude<keyof ExtractType<T> | E, symbol>}` : T extends object ? `${Exclude<keyof ExtractType<T> | E, symbol>}` : never;
 type Defined<T> = Exclude<T, null | undefined>;
-type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : (K extends E ? keyof T : never);
+type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : K extends E ? keyof T : never;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 export type AutoPath<O, P extends string, E extends string = never, D extends Prev[number] = 5> = [D] extends [never] ? string : P extends any ? (P & `${string}.` extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<Defined<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (Defined<GetStringKey<O, Q, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<Defined<GetStringKey<O, Q, E>>, E> extends never ? never : `${Q}.`) : keyof ExtractType<O> : never : never;
 export declare enum QueryOrder {
@@ -297,7 +302,7 @@ export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
 export type QueryOrderMap<T> = {
     [K in keyof T as ExcludeFunctions<T, K>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
 };
-export type EntityField<T, P extends string = never> = AutoPath<T, P, '*'>;
+export type EntityField<T, P extends string = never> = AutoPath<T, P, "*">;
 export interface FindOptions<T, P extends string = never> {
     load?: readonly AutoPath<T, P>[];
     orderBy?: (QueryOrderMap<T> & {
@@ -308,7 +313,7 @@ export interface FindOptions<T, P extends string = never> {
     offset?: number;
     fields?: readonly EntityField<T, P>[];
     schema?: string;
-    loadStrategy?: 'select' | 'joined';
+    loadStrategy?: "select" | "joined";
 }
-export type FindOneOption<T, P extends string = never> = Omit<FindOptions<T, P>, 'limit' | 'offset'>;
+export type FindOneOption<T, P extends string = never> = Omit<FindOptions<T, P>, "limit" | "offset">;
 export {};

package/dist/orm.service.d.ts

@@ -4,6 +4,7 @@ export declare class OrmService {
     private orm;
     private storage;
     private allEntities;
+    private project;
     constructor(orm: Orm, storage: EntityStorage, entityFile?: string);
     private discoverRelationshipTypes;
     private discoverEnumTypes;

package/dist/orm.service.js

@@ -58,7 +58,8 @@ let OrmService = class OrmService {
         this.orm = orm;
         this.storage = storage;
         this.allEntities = new Map();
-        const files = new ts_morph_1.Project({ skipLoadingLibFiles: true }).addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths());
+        this.project = new ts_morph_1.Project({ skipLoadingLibFiles: true });
+        const files = this.project.addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths());
         files.forEach(file => {
             file.getClasses().forEach(classDeclaration => {
                 if (classDeclaration.getDecorator('Entity')) {
@@ -281,8 +282,7 @@ let OrmService = class OrmService {
             console.log('No entities found!');
             return;
         }
-        const files = new ts_morph_1.Project({ skipLoadingLibFiles: true })
-            .addSourceFilesAtPaths(this.getSourceFilePaths());
+        const files = this.project.getSourceFiles();
         this.discoverRelationshipTypes(files);
         this.discoverEnumTypes(files, entities);
         for (const entity of entities) {
@@ -320,7 +320,23 @@ let OrmService = class OrmService {
     }
     getSourceFilePaths() {
         const projectRoot = process.cwd();
-        const patterns = ['**/*.ts', '**/*.js', '!**/node_modules/**'];
+        const patterns = [
+            '**/*.entity.ts',
+            '**/entities/**/*.ts',
+            '**/entity/**/*.ts',
+            '**/*.entity.js',
+            '**/entities/**/*.js',
+            '**/entity/**/*.js',
+            '!**/node_modules/**',
+            '!**/test/**',
+            '!**/tests/**',
+            '!**/*.spec.ts',
+            '!**/*.test.ts',
+            '!**/*.spec.js',
+            '!**/*.test.js',
+            '!**/dist/**',
+            '!**/build/**'
+        ];
         try {
             return globby
                 .sync(patterns, { cwd: projectRoot, gitignore: true, absolute: false })

package/dist/testing/with-database.js

@@ -75,11 +75,12 @@ async function withDatabase(arg1, arg2, arg3) {
         const session = await createSession(targetOptions);
         cachedSession = {
             orm: session.orm,
-            tables: [],
             schema: session.schema,
+            storage: session.storage,
         };
         sessionCache.set(cacheKey, cachedSession);
     }
+    activateSession(cachedSession);
     const context = buildContext(cachedSession.orm);
     await dropAndRecreateSchema(context, cachedSession.schema);
     await prepareSchema(context, cachedSession.schema);
@@ -89,8 +90,9 @@ async function withDatabase(arg1, arg2, arg3) {
 async function createSession(options) {
     const logger = selectLogger(options);
     const orm = new orm_1.Orm(logger);
-    await initializeOrm(orm, options);
-    return { orm, schema: options.schema ?? DEFAULT_SCHEMA };
+    const storage = new entities_1.EntityStorage();
+    await initializeOrm(orm, storage, options);
+    return { orm, schema: options.schema ?? DEFAULT_SCHEMA, storage };
 }
 function selectLogger(options) {
     if (options.logger) {
@@ -99,8 +101,7 @@ function selectLogger(options) {
     const config = { applicationConfig: { logger: { level: 'info' } } };
     return new core_1.LoggerService(config);
 }
-async function initializeOrm(orm, options) {
-    const storage = new entities_1.EntityStorage();
+async function initializeOrm(orm, storage, options) {
     if (options.entityFile) {
         const entityFiles = await (0, globby_1.default)(options.entityFile, { absolute: true });
         for (const file of entityFiles) {
@@ -111,6 +112,10 @@ async function initializeOrm(orm, options) {
     const connection = resolveConnection(options.connection);
     await service.onInit(connection);
 }
+function activateSession(session) {
+    orm_1.Orm.instance = session.orm;
+    entities_1.EntityStorage.instance = session.storage;
+}
 function resolveConnection(overrides) {
     if (!overrides) {
         return DEFAULT_CONNECTION;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.136",
+  "version": "0.1.141",
   "description": "A simple ORM for Cheetah.js.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "2109d17dd39ca357d6a0b48bf0b7bb08270fe8b6"
+  "gitHead": "f3f3004bde2d552db43db3ac56b4d286bbfbc7f6"
 }