@cheetah.js/orm 0.1.0

package/README.md

@@ -0,0 +1,228 @@
+# Cheetah.js ORM
+Cheetah.js ORM is a simple and powerful ORM for Cheetah.js and Bun.
+<br>We don't use any query builder like knex, we have our own query builder making us faster.
+**In development.**
+
+### Menu
+- [Installation](#install)
+- [Entities](#entities)
+- [Usage](#usage)
+
+### [Installation](#install)
+For install Cheetah.js ORM, run the command below:
+
+```bash
+bun install @cheetah.js/orm
+```
+Create a configuration file for the ORM in the root of the project called "cheetah.config.ts" and configure the database connection, providers and entities:
+
+```javascript
+import { PgDriver } from '@cheetah.js/orm';
+import { ConnectionSettings } from '@cheetah.js/orm/driver/driver.interface';
+
+const config: ConnectionSettings<any> = {
+  host: 'localhost',
+  port: 5432,
+  database: 'postgres',
+  username: 'postgres',
+  password: 'postgres',
+  driver: PgDriver,
+  migrationPath: 'path_migrations', 
+  entities: 'entity/*.ts' // or [User, Post, ...]
+};
+
+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.
+<br/>
+<br/>
+After that, you need to import the ORM into the project and add it to the Cheetah.js instance:
+    
+```javascript
+import { Cheetah } from '@cheetah.js/core';
+import { CheetahOrm } from '@cheetah.js/orm';
+
+new Cheetah().use(CheetahOrm).listen();
+```
+
+### [Entities](#entities)
+Entities are classes that map to database tables. Each entity must have a primary key.
+
+#### Example:
+```javascript
+import { Entity, PrimaryKey, Property } from '@cheetah.js/orm';
+
+@Entity()
+export class User {
+  @PrimaryKey()
+  id: number;
+
+  @Property()
+  name: string;
+}
+```
+
+#### PrimaryKey
+The @PrimaryKey decorator is used to define the primary key of the entity.
+
+#### Nullable property
+For define a nullable property, add a parameter to the @Property decorator:
+
+```javascript
+@Entity()
+export class User {
+    @PrimaryKey()
+    id: number;
+
+    @Property({ nullable: true })
+    name: string;
+}
+```
+Cheetah ORM can also distinguish nullable properties automatically by adding the question mark to the end of the property name:
+
+```javascript
+export class User {
+    @PrimaryKey()
+    id: number;
+
+    @Property()
+    name?:string;
+}
+```
+
+#### Unique property
+For define a unique property, add a parameter to the @Property decorator:
+
+```javascript
+@Entity()
+export class User {
+    @PrimaryKey()
+    id: number;
+
+    @Property({ unique: true })
+    name: string;
+}
+```
+
+#### Index property
+For define a index for a unique property, add a parameter to the @Property decorator:
+
+```javascript
+@Entity()
+export class User {
+    @PrimaryKey()
+    id: number;
+
+    @Property({ index: true })
+    name: string;
+}
+```
+
+For define a index for a multiple properties, add the @Index decorator:
+
+```javascript
+@Entity()
+export class User {
+    @PrimaryKey()
+    id: number;
+
+    @Property()
+    name: string;
+
+    @Index(['name', 'email'])
+    @Property()
+    email: string;
+}
+```
+
+#### Property options
+| Option | Type | Description                                                                                |
+| ------ | ---- |--------------------------------------------------------------------------------------------|
+| nullable | boolean | Defines if the property is nullable.                                                       |
+| unique | boolean | Defines if the property is unique.                                                         |
+| index | boolean | Defines if the property is index.                                                          |
+| default | any | Defines the default value of the property.                                                 |
+| length | number | Defines the length of the property.                                                        |
+| onUpdate | string | Define the action to be taken for this property when updating the entity in the database   |
+| onInsert | string | Defines the action to be taken for this property when inserting the entity in the database |
+
+#### Relations
+Cheetah ORM supports relations between entities. The available relations are: OneToMany, ManyToOne.
+
+##### OneToMany
+The OneToMany relation is used to define a one-to-many relationship between two entities. For example, a user can have multiple posts, but a post can only have one user.
+
+```javascript
+@Entity()
+export class User {
+    @PrimaryKey()
+    id: number;
+
+    @Property()
+    name: string;
+
+    @OneToMany(() => Post, (post) => post.user)
+    posts: Post[];
+}
+```
+
+#### ManyToOne
+The owner side of the relation is the side that has the @ManyToOne decorator. The inverse side is the side that has the @OneToMany decorator. The owner side is always the side that has the foreign key.
+
+```javascript
+@Entity()
+export class Post {
+    @PrimaryKey()
+    id: number;
+
+    @Property()
+    title: string;
+
+    @ManyToOne(() => User)
+    user: User;
+}
+```
+
+### [Usage](#usage)
+#### Create a new entity
+```javascript
+import { User } from './entity/user';
+
+const user = User.create({ name: 'John Doe' });
+
+// OR
+const user = new User();
+user.name = 'John Doe';
+await user.save();
+```
+
+#### Find a entity
+```javascript
+import { User } from './entity/user';
+
+const user = await User.findOne({ 
+    name: 'John Doe',
+    old: { $gte: 16, $lte: 30 }
+});
+```
+
+#### List of supported operators
+| Operator |Name | Description |
+| ------ | ---- |--------------------------------------------------------------------------------------------|
+| $eq | Equal | Matches values that are equal to a specified value. |
+| $gt | Greater Than | Matches values that are greater than a specified value. |
+| $gte | Greater Than or Equal | Matches values that are greater than or equal to a specified value. |
+| $in | In | Matches any of the values specified in an array. |
+| $lt | Less Than | Matches values that are less than a specified value. |
+| $lte | Less Than or Equal | Matches values that are less than or equal to a specified value. |
+| $ne | Not Equal | Matches all values that are not equal to a specified value. |
+| $nin | Not In | Matches none of the values specified in an array. |
+| $and | And | Joins query clauses with a logical AND returns all documents that match the conditions of both clauses. |
+ | $or | Or | Joins query clauses with a logical OR returns all documents that match the conditions of either clause. |
+| $not | Not | Inverts the effect of a query expression and returns documents that do not match the query expression. |
+
+
+
+

package/build.ts

@@ -0,0 +1,14 @@
+import { copyFileSync } from 'fs'
+
+await Bun.build({
+  entrypoints: ['./src/index.ts'],
+  outdir: './dist/bun',
+  minify: false,
+  target: 'bun',
+  sourcemap: 'external',
+  splitting: true
+})
+
+copyFileSync('dist/index.d.ts', 'dist/bun/index.d.ts')
+
+export {}

package/cheetah.config.ts

@@ -0,0 +1,14 @@
+import { PgDriver } from '@cheetah.js/orm';
+import { ConnectionSettings } from '@cheetah.js/orm/driver/driver.interface';
+
+const config: ConnectionSettings<any> = {
+  host: 'localhost',
+  port: 5432,
+  database: 'postgres',
+  username: 'postgres',
+  password: 'postgres',
+  driver: PgDriver,
+  migrationPath: '/packages/orm/test/migration'
+};
+
+export default config;

package/dist/SqlBuilder.d.ts

@@ -0,0 +1,57 @@
+import { AutoPath, FilterQuery, QueryOrderMap } from './driver/driver.interface';
+export declare class SqlBuilder<T> {
+    private readonly driver;
+    private entityStorage;
+    private statements;
+    private entity;
+    private model;
+    private aliases;
+    private lastKeyNotOperator;
+    private logger;
+    private updatedColumns;
+    constructor(model: new () => T);
+    select(columns?: AutoPath<T, never, '*'>[]): SqlBuilder<T>;
+    insert(values: Partial<T>): SqlBuilder<T>;
+    update(values: Partial<T>): SqlBuilder<T>;
+    where(where: FilterQuery<T>): SqlBuilder<T>;
+    orderBy(orderBy: (QueryOrderMap<T> & {
+        0?: never;
+    }) | QueryOrderMap<T>[]): SqlBuilder<T>;
+    limit(limit: number | undefined): SqlBuilder<T>;
+    offset(offset: number | undefined): SqlBuilder<T>;
+    executeAndReturnFirst(): Promise<T | undefined>;
+    executeAndReturnFirstOrFail(): Promise<T>;
+    executeAndReturnAll(): Promise<T[]>;
+    execute(): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    startTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    inTransaction<T>(callback: (builder: SqlBuilder<T>) => Promise<T>): Promise<T>;
+    private objectToStringMap;
+    private discoverColumnAlias;
+    private getTableName;
+    private addSimpleConditionToSql;
+    private addInConditionToSql;
+    private addLogicalOperatorToSql;
+    private conditionToSql;
+    private t;
+    private applyJoin;
+    private getFkKey;
+    private getEntity;
+    private transformToModel;
+    /**
+     * Retrieves an alias for a given table name.
+     *
+     * @param {string} tableName - The name of the table.
+     * @private
+     * @returns {string} - The alias for the table name.
+     */
+    private getAlias;
+    private getColumnsEntity;
+    private withDefaultValues;
+    private withUpdatedValues;
+}