@cheetah.js/orm 0.1.3 → 0.1.5

package/src/common/uuid.ts

@@ -0,0 +1,8 @@
+import { ValueObject } from '@cheetah.js/orm';
+
+export class Uuid extends ValueObject<string, Uuid> {
+
+  protected validate(value: string): boolean {
+    return /^[a-f\d]{8}(-[a-f\d]{4}){4}[a-f\d]{8}$/i.test(value);
+  }
+}

package/src/common/value-object.ts

@@ -5,6 +5,16 @@ type VoExtended<T, Vo> = Vo extends ValueObject<T, Vo>
   : ValueObject<T, Vo>;
 
 export abstract class ValueObject<T, Vo> {
+  /**
+   * Validates the value of the Value Object.
+   * It is abstract so that each Value Object can implement its own validation.
+   * It is protected from being called directly.
+   *
+   * @param value
+   * @protected
+   */
+  protected abstract validate(value: T): boolean;
+
   /**
    * Valor do Value Object.
    * É privado para não ser alterado diretamente.
@@ -16,8 +26,7 @@ export abstract class ValueObject<T, Vo> {
 
   constructor(value: T) {
     if (!this.validate(value)) {
-      //@ts-ignore
-      throw new HttpException(`Invalid value for ${this.name}`, 400);
+      throw new HttpException(`Invalid value for ${this.constructor.name}`, 400);
     }
 
     this.setValue(value);
@@ -55,16 +64,6 @@ export abstract class ValueObject<T, Vo> {
     return this.getValue() === vo.getValue();
   }
 
-  /**
-   * Validates the value of the Value Object.
-   * It is abstract so that each Value Object can implement its own validation.
-   * It is protected from being called directly.
-   *
-   * @param value
-   * @protected
-   */
-  protected abstract validate(value: T): boolean;
-
   /**
    * Sets the value of the Value Object.
    *

package/src/decorators/property.decorator.ts

@@ -8,6 +8,7 @@ export type PropertyOptions = {
   default?: any;
   length?: number;
   unique?: boolean;
+  dbType?: 'varchar' | 'text' | 'int' | 'bigint' | 'float' | 'double' | 'decimal' | 'date' | 'datetime' | 'time' | 'timestamp' | 'boolean' | 'json' | 'jsonb' | 'enum' | 'array' | 'uuid';
   autoIncrement?: boolean;
   onUpdate?: () => any;
   onInsert?: () => any;

package/src/domain/base-entity.ts

@@ -1,5 +1,5 @@
 import { SqlBuilder } from '../SqlBuilder';
-import { FilterQuery, FindOneOption, FindOptions, InstanceOf } from '../driver/driver.interface';
+import { FilterQuery, FindOneOption, FindOptions, InstanceOf, ValueOrInstance } from '../driver/driver.interface';
 
 export abstract class BaseEntity {
   private _oldValues: any = {};
@@ -112,21 +112,13 @@ export abstract class BaseEntity {
 
   static async create<T extends BaseEntity>(
     this: { new(): T } & typeof BaseEntity,
-    where: Partial<InstanceOf<T>>,
+    where: Partial<{ [K in keyof T]: ValueOrInstance<T[K]> }>,
   ): Promise<T> {
     return this.createQueryBuilder<T>()
       .insert(where)
       .executeAndReturnFirstOrFail();
   }
 
-  static getTableName(): string {
-    if ('tableName' in this) {
-      return (this as any).tableName;
-    }
-
-    return this.name.toLowerCase();
-  }
-
   public async save() {
     const qb = this.createQueryBuilder()
 

package/src/domain/entities.ts

@@ -72,9 +72,10 @@ export class EntityStorage {
     let properties: ColumnsInfo[] = Object.entries(values.showProperties).map(([key, value]) => {
       return {
         name: key,
-        type: value.type.name,
+        type: value.options.dbType ?? value.type.name,
         nullable: value.options?.nullable,
         default: value.options?.default,
+        autoIncrement: value.options?.autoIncrement,
         primary: value.options?.isPrimary,
         unique: value.options?.unique,
         length: value.options?.length,
@@ -91,6 +92,7 @@ export class EntityStorage {
         unique: relation.unique,
         length: relation.length || getDefaultLength(type),
         default: relation.default,
+        autoIncrement: relation.autoIncrement,
         primary: relation.isPrimary,
         foreignKeys: [
           {

package/src/driver/driver.interface.ts

@@ -1,6 +1,7 @@
 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;
@@ -37,6 +38,9 @@ export interface DriverInterface {
   rollbackTransaction(): Promise<void>;
 }
 
+// @ts-ignore
+export type ValueOrInstance<T> = T extends ValueObject<any, any> ? T | T['value'] : NonNullable<T>;
+
 export type SnapshotConstraintInfo = {
   indexName: string;
   consDef: string;
@@ -158,6 +162,7 @@ export type ColumnsInfo = {
   default?: string | null;
   primary?: boolean;
   unique?: boolean;
+  autoIncrement?: boolean;
   length?: number;
   foreignKeys?: ForeignKeyInfo[];
 }
@@ -175,6 +180,7 @@ export type ColDiff = {
     primary?: boolean;
     unique?: boolean;
     nullable?: boolean;
+    autoIncrement?: boolean;
     foreignKeys?: ForeignKeyInfo[];
   };
 }
@@ -226,17 +232,19 @@ export type OperatorMap<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 ? ValueOrInstance<T> : (K extends symbol ? never : K);
 export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | {
   toHexString(): string;
 };
 //TODO: editar
-export type ExpandProperty<T> = T extends (infer U)[] ? NonNullable<U> : NonNullable<T> ;
-export type ExpandScalar<T> = null | (T extends string ? T | RegExp : T extends Date ? Date | string : T);
+export type ExpandProperty<T> = T extends (infer U)[] ? ValueOrInstance<U> : ValueOrInstance<T> ;
+export type ExpandScalar<T> = null | ValueOrInstance<T> | (T extends string ? T | RegExp : T extends Date ? Date | string : T);
 type ExpandObject<T> = T extends object ? T extends Scalar ? never : {
+  // @ts-ignore
   -readonly [K in keyof T as ExcludeFunctions<T, K>]?: Query<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null;
 } : never;
 export type EntityProps<T> = {
+  // @ts-ignore
   -readonly [K in keyof T as ExcludeFunctions<T, K>]?: T[K];
 };
 export type Query<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
@@ -245,7 +253,7 @@ export type FilterValue<T> = OperatorMap<FilterValue2<T>> | FilterValue2<T> | Fi
 export type EntityClass<T> = Function & { prototype: T };
 export type EntityName<T> = string | EntityClass<T>  | { name: string };
 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 FilterQuery<T> = ValueOrInstance<T> | ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
 
 export type Relationship<T> = {
   isRelation?: boolean;
@@ -315,6 +323,7 @@ export declare enum QueryOrderNumeric {
 export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder;
 export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
 export type QueryOrderMap<T> = {
+  // @ts-ignore
   [K in keyof T as ExcludeFunctions<T, K>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
 };
 export type EntityField<T, P extends string = never> = AutoPath<T, P, '*'>;

package/src/driver/pg-driver.ts

@@ -29,9 +29,11 @@ export class PgDriver implements DriverInterface {
 
   getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]) {
     return `CREATE TABLE "${schema}"."${tableName}" (${creates.map(colDiff => {
-      let sql = `"${colDiff.colName}" ${colDiff.colType}${(colDiff.colLength ? `(${colDiff.colLength})` : '')}`;
-
-      if (!colDiff.colChanges?.nullable) {
+      const isAutoIncrement = colDiff.colChanges?.autoIncrement;
+    
+      let sql = `"${colDiff.colName}" ${isAutoIncrement ? 'SERIAL' : colDiff.colType + (colDiff.colLength ? `(${colDiff.colLength})` : '')}`;
+    
+      if (!isAutoIncrement && !colDiff.colChanges?.nullable) {
         sql += ' NOT NULL';
       }
 

package/src/index.ts

@@ -9,4 +9,7 @@ export * from './domain/base-entity'
 export * from './driver/pg-driver'
 export * from './utils'
 export * from './driver/driver.interface'
-export * from './entry'
+export * from './entry'
+export * from './common/value-object'
+export * from './common/email.vo'
+export * from './common/uuid'

package/src/migration/diff-calculator.ts

@@ -77,11 +77,14 @@ export class DiffCalculator {
 
   private checkIndexes(bdTable: SnapshotTable | undefined, entityTable: SnapshotTable | undefined, colDiffs: ColDiff[]) {
     if ((bdTable && bdTable.indexes) || (entityTable && entityTable.indexes)) {
-      if (!bdTable || !bdTable.indexes){
+      if (!bdTable || !bdTable.indexes) {
         colDiffs.push({
           actionType: 'INDEX',
           colName: '*',
-          indexTables: entityTable!.indexes.map(index => ({name: index.indexName, properties: index.columnName.split(',')})),
+          indexTables: entityTable!.indexes.map(index => ({
+            name: index.indexName,
+            properties: index.columnName.split(','),
+          })),
         });
       }
 
@@ -89,7 +92,7 @@ export class DiffCalculator {
         colDiffs.push({
           actionType: 'INDEX',
           colName: '*',
-          indexTables: bdTable!.indexes.map(index => ({ name: index.indexName })),
+          indexTables: bdTable!.indexes.map(index => ({name: index.indexName})),
         });
       }
     }
@@ -119,13 +122,15 @@ export class DiffCalculator {
   }
 
   private createNewColumn(entityCol: ColumnsInfo, colDiffs: ColDiff[]): ColDiff[] {
+    const colType = this.convertEntityTypeToSqlType(entityCol.type);
 
     colDiffs.push({
       actionType: 'CREATE',
       colName: entityCol.name,
-      colType: this.convertEntityTypeToSqlType(entityCol.type),
-      colLength: entityCol.length,
+      colType: colType.type,
+      colLength: entityCol.length ?? colType.len,
       colChanges: {
+        autoIncrement: entityCol.autoIncrement,
         default: entityCol.default,
         primary: entityCol.primary,
         unique: entityCol.unique,
@@ -138,12 +143,15 @@ export class DiffCalculator {
   }
 
   private diffColumnType(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]): void {
-    if (bdCol.type !== this.convertEntityTypeToSqlType(entityCol.type) || bdCol.length !== entityCol.length) {
+    const colT = this.convertEntityTypeToSqlType(entityCol.type);
+    const colType = colT.type;
+    const length = entityCol.length ?? colT.len;
+    if (bdCol.type !== colType || bdCol.length !== length) {
       colDiffs.push({
         actionType: 'ALTER',
         colName: entityCol.name,
-        colType: this.convertEntityTypeToSqlType(entityCol.type),
-        colLength: entityCol.length,
+        colType: colType,
+        colLength: length,
       });
     }
   }
@@ -244,14 +252,35 @@ export class DiffCalculator {
   }
 
   // TODO: Precisa ser de acordo com o driver
-  private convertEntityTypeToSqlType(entityType: string): string {
+  // adicionar  'varchar' | 'text' | 'int' | 'bigint' | 'float' | 'double' | 'decimal' | 'date' | 'datetime' | 'time' | 'timestamp' | 'boolean' | 'json' | 'jsonb' | 'enum' | 'array' | 'uuid'
+  private convertEntityTypeToSqlType(entityType: string): { type: string, len?: number } {
     switch (entityType) {
       case "Number":
-        return "numeric";
+      case 'int':
+        return {type: 'numeric', len: 11};
+      case 'bigint':
+        return {type: 'bigint'};
+      case 'float':
+        return {type: 'float4'};
+      case 'double':
+        return {type: 'float8'};
+      case 'decimal':
+        return {type: 'decimal'};
       case "String":
-        return "character varying";
+      case "varchar":
+        return {type: 'character varying', len: 255};
+      case "Boolean":
+        return {type: "boolean"};
+      case "Date":
+        return {type: "timestamp"};
+      case "Object":
+        return {type: "json"};
+      case 'uuid':
+        return {type: 'uuid'};
+      case 'text':
+        return {type: 'text'};
       default:
-        return "character varying"
+        return {type: "character varying", len: 255};
       //... mais casos aqui ...
     }
   }

package/src/utils.ts

@@ -1,18 +1,3 @@
 export function getDefaultLength(type: string): number {
-  if (type === 'String') {
-    return 255;
-  }
-
-  if (type === 'Number') {
-    return 11;
-  }
-
-  if (type === 'Boolean') {
-    return 1;
-  }
-
-  if (type === 'Date') {
-    return 6;
-  }
-  return 255;
+  return null;
 }

package/test/domain/base-entity.spec.ts

@@ -1,6 +1,7 @@
-import { afterEach, beforeEach, describe, expect, jest, test, setSystemTime } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, jest, setSystemTime, test } from 'bun:test'
 import { app, execute, mockLogger, purgeDatabase, startDatabase } from '../node-database';
 import { BaseEntity, Entity, OneToMany, PrimaryKey, Property } from '../../src';
+import { Email } from '../../src/common/email.vo';
 
 @Entity()
 class UserTest extends BaseEntity {
@@ -14,6 +15,15 @@ class UserTest extends BaseEntity {
   updatedAt: Date;
 }
 
+@Entity()
+class UserValue extends BaseEntity {
+  @PrimaryKey()
+  id: number;
+
+  @Property()
+  email: Email
+}
+
 describe('Creation, update and deletion of entities', () => {
 
   const DLL = `
@@ -454,6 +464,40 @@ describe('Creation, update and deletion of entities', () => {
     expect(created!.updatedAt).toEqual(dateNow);
   })
 
+  test('When have a column with value-object', async() => {
+    const DLL = `
+      CREATE TABLE "uservalue"
+      (
+          "id"    SERIAL PRIMARY KEY,
+          "email" varchar(255) NOT NULL
+      );
+  `;
+
+    await purgeDatabase()
+    await startDatabase(import.meta.path)
+    await execute(DLL)
+
+    Entity()(UserValue)
+    const created = await UserValue.create({
+      id: 1,
+      email: Email.from('test@test.com')
+    })
+
+    const find = await UserValue.findOne({
+      email: Email.from('test@test.com'),
+      id: 1
+    })
+
+    expect(created).toBeInstanceOf(UserValue);
+    expect(created!.id).toEqual(1);
+    expect(created!.email).toEqual(Email.from('test@test.com'));
+
+    expect(find).toBeInstanceOf(UserValue);
+    expect(find!.id).toEqual(1);
+    expect(find!.email).toEqual(Email.from('test@test.com'));
+  })
+
+
   async function createUser() {
     return User.create({
       email: 'test@test.com',

package/test/migration/{migator.spec.ts → migrator.spec.ts}

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import { Metadata } from '@cheetah.js/core';
 import { ENTITIES } from '../../src/constants';
 import { Index } from '../../src/decorators/index.decorator';
+import { Email } from '../../src/common/email.vo';
 
 describe('Migration', () => {
 
@@ -248,4 +249,48 @@ describe('Migration', () => {
     expect(migrationContent.split('\n').length).toEqual(5)
     await execute(migrationContent);
   });
+
+  it('should create with value-objects', async () => {
+    class User extends BaseEntity {
+      @PrimaryKey()
+      id: number;
+
+      @Property({ dbType: 'text' })
+      email: Email;
+    }
+
+    Entity()(User);
+
+    const migrator = new Migrator();
+    await migrator.initConfigFile();
+    await migrator.createMigration( 'test');
+    const migrationFilePath = path.join(__dirname, '/test.sql');
+    const migrationContent = fs.readFileSync(migrationFilePath, {encoding: 'utf-8'});
+
+    expect(migrationContent).toContain("CREATE TABLE \"public\".\"user\" (\"id\" numeric(11) NOT NULL PRIMARY KEY UNIQUE,\"email\" text NOT NULL);")
+    expect(migrationContent.split('\n').length).toEqual(1)
+    await execute(migrationContent);
+  });
+
+  it('should create with auto-increment', async () => {
+    class User extends BaseEntity {
+      @PrimaryKey({ autoIncrement: true })
+      id: number;
+
+      @Property({ dbType: 'text' })
+      email: Email;
+    }
+
+    Entity()(User);
+
+    const migrator = new Migrator();
+    await migrator.initConfigFile();
+    await migrator.createMigration( 'test');
+    const migrationFilePath = path.join(__dirname, '/test.sql');
+    const migrationContent = fs.readFileSync(migrationFilePath, {encoding: 'utf-8'});
+
+    expect(migrationContent).toContain("CREATE TABLE \"public\".\"user\" (\"id\" SERIAL PRIMARY KEY UNIQUE,\"email\" text NOT NULL);")
+    expect(migrationContent.split('\n').length).toEqual(1)
+    await execute(migrationContent);
+  });
 })

package/test/migration/test.sql

@@ -1,5 +1 @@
-CREATE TABLE "public"."user" ("id" numeric(11) NOT NULL PRIMARY KEY UNIQUE,"email" character varying(255) NOT NULL);
-CREATE INDEX "id_email_index" ON "public"."user" ("id", "email");
-CREATE INDEX "email_index" ON "public"."user" ("email");
-CREATE TABLE "public"."address" ("id" numeric(11) NOT NULL PRIMARY KEY UNIQUE,"user" numeric(11) NOT NULL);
-ALTER TABLE "public"."address" ADD CONSTRAINT "address_user_fk" FOREIGN KEY ("user") REFERENCES "user" ("id");
+CREATE TABLE "public"."user" ("id" SERIAL PRIMARY KEY UNIQUE,"email" text NOT NULL);