@cheetah.js/orm 0.1.0

package/src/domain/base-entity.ts

@@ -0,0 +1,149 @@
+import { SqlBuilder } from '../SqlBuilder';
+import { FilterQuery, FindOneOption, FindOptions, InstanceOf } from '../driver/driver.interface';
+
+export abstract class BaseEntity {
+  private _oldValues: any = {};
+  private _changedValues: any = {};
+  private $_isPersisted: boolean = false;
+
+  constructor() {
+    return new Proxy(this, {
+      set(target: any, p: string, newValue: any): boolean {
+
+        if (p.startsWith('$')) {
+          target[p] = newValue;
+          return true;
+        }
+
+        // se oldvalue não existir, é porque é a primeira vez que o atributo está sendo setado
+        if (!target._oldValues[p]) {
+          target._oldValues[p] = newValue;
+        }
+
+        // se o valor for diferente do valor antigo, é porque o valor foi alterado
+        if (target._oldValues[p] !== newValue) {
+          target._changedValues[p] = newValue;
+        }
+
+        target[p] = newValue;
+
+        return true;
+      },
+    })
+  }
+
+  /**
+   * Gets current entity's Repository.
+   */
+  static createQueryBuilder<T>(
+    this: { new(): T } & typeof BaseEntity,
+  ): SqlBuilder<T> {
+    return new SqlBuilder<T>(this);
+  }
+
+  /**
+   * Gets current entity's Repository.
+   */
+  private createQueryBuilder<T>(): SqlBuilder<T> {
+    // @ts-ignore
+    return new SqlBuilder<T>(this.constructor);
+  }
+
+  static async find<T, Hint extends string = never>(
+    this: { new(): T } & typeof BaseEntity,
+    where: FilterQuery<T>,
+    options?: FindOptions<T, Hint>
+  ): Promise<T[]> {
+    return this.createQueryBuilder<T>()
+      .select(options?.fields as any)
+      .where(where)
+      .limit(options?.limit)
+      .offset(options?.offset)
+      .orderBy(options?.orderBy as string[])
+      .executeAndReturnAll();
+  }
+
+  static async findOne<T, Hint extends string = never>(
+    this: { new(): T } & typeof BaseEntity,
+    where: FilterQuery<T>,
+    options?: FindOneOption<T, Hint>
+  ): Promise<T | undefined> {
+    return this.createQueryBuilder<T>()
+      .select(options?.fields as any)
+      .where(where)
+      .executeAndReturnFirst();
+  }
+
+  /**
+   * Find a record in the database based on the provided query where and return it, or throw an error if not found.
+   *
+   * @param {FilterQuery<T>} where - The query where used to search for the record.
+   * @param options
+   * @return {Promise<T>} - A promise that resolves with the found record.
+   */
+  static async findOneOrFail<T, Hint extends string = never>(
+    this: { new(): T } & typeof BaseEntity,
+    where: FilterQuery<T>,
+    options?: FindOneOption<T, Hint>
+  ): Promise<T> {
+    return this.createQueryBuilder<T>()
+      // @ts-ignore
+      .select(options?.fields)
+      .where(where)
+      .orderBy(options?.orderBy as string[])
+      .executeAndReturnFirstOrFail();
+  }
+
+  static async findAll<
+    T extends object,
+    Hint extends string = never
+  >(
+    this: { new(): T } & typeof BaseEntity,
+    options: FindOptions<T, Hint>
+  ): Promise<T[]> {
+    const builder = this.createQueryBuilder<T>()
+      .select(options.fields as any)
+      .offset(options?.offset)
+      .limit(options.limit)
+      .orderBy(options?.orderBy as string[]);
+
+    return builder.executeAndReturnAll();
+  }
+
+  static async create<T extends BaseEntity>(
+    this: { new(): T } & typeof BaseEntity,
+    where: Partial<InstanceOf<T>>,
+  ): 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()
+
+    if (this.$_isPersisted) {
+      qb.update(this._changedValues)
+        // @ts-ignore
+        .where({id: this._oldValues.id})
+    } else {
+      qb.insert(this._oldValues)
+    }
+
+    await qb.execute()
+
+    this._oldValues = {
+      ...this._oldValues,
+      ...this._changedValues,
+    }
+    this._changedValues = {}
+  }
+}

package/src/domain/collection.ts

@@ -0,0 +1,10 @@
+export class ArrayCollection<T extends object, O extends object> {
+  getItems(): T[] {
+    return [];
+  }
+}
+export class Collection<T extends object, O extends object = object> extends ArrayCollection<T, O> {
+  constructor(owner: O, items?: T[], initialized = true) {
+    super();
+  }
+}

package/src/domain/entities.ts

@@ -0,0 +1,159 @@
+import { Metadata, Service } from '@cheetah.js/core';
+import { PropertyOptions } from '../decorators/property.decorator';
+import { ColumnsInfo, Relationship, SnapshotIndexInfo, SnapshotTable } from '../driver/driver.interface';
+import { getDefaultLength } from '../utils';
+
+export type Property = {
+  options: PropertyOptions;
+  type: Function;
+}
+
+export type Options = {
+  showProperties: { [key: string]: Property };
+  hideProperties: string[];
+  indexes?: SnapshotIndexInfo[];
+  relations: Relationship<any>[];
+  tableName: string;
+  schema?: string;
+}
+
+@Service()
+export class EntityStorage {
+  static instance: EntityStorage;
+
+  private entities: Map<Function, Options> = new Map();
+
+  constructor() {
+    EntityStorage.instance = this;
+  }
+
+  add(entity: { target: Function, options: any }, properties: {[key: string]: Property}, relations: Relationship<any>[]) {
+    const entityName = entity.options?.tableName || entity.target.name.toLowerCase();
+    const indexes = Metadata.get('indexes', entity.target) || [];
+    this.entities.set(entity.target, {
+      showProperties: properties,
+      hideProperties: [],
+      relations,
+      indexes: indexes.map((index: {name: string, properties: string[]}) => {
+        return {
+          table: entityName,
+          indexName: index.name.replace('[TABLE]', entityName),
+          columnName: index.properties.join(','),
+        }
+      }),
+      tableName: entityName,
+      ...entity.options
+    })
+  }
+
+  get(entity: Function) {
+    return this.entities.get(entity);
+  }
+
+  entries() {
+    return this.entities.entries();
+  }
+
+  static getInstance() {
+    return EntityStorage.instance;
+  }
+
+  async snapshot(values: Options): Promise<SnapshotTable> {
+    return {
+      tableName: values.tableName,
+      schema: values.schema || 'public',
+      indexes: values.indexes || [],
+      columns: this.snapshotColumns(values),
+    }
+  }
+
+  private snapshotColumns(values: Options): ColumnsInfo[] {
+
+    let properties: ColumnsInfo[] = Object.entries(values.showProperties).map(([key, value]) => {
+      return {
+        name: key,
+        type: value.type.name,
+        nullable: value.options?.nullable,
+        default: value.options?.default,
+        primary: value.options?.isPrimary,
+        unique: value.options?.unique,
+        length: value.options?.length,
+      }
+    })
+    // @ts-ignore
+    let relations: ColumnsInfo[] = values.relations && values.relations.map((relation) => {
+      const type = this.getFkType(relation)
+
+      return {
+        name: relation.propertyKey as string,
+        type,
+        nullable: relation.nullable,
+        unique: relation.unique,
+        length: relation.length || getDefaultLength(type),
+        default: relation.default,
+        primary: relation.isPrimary,
+        foreignKeys: [
+          {
+            referencedColumnName: this.getFkKey(relation),
+            referencedTableName: this.get(relation.entity() as any)!.tableName,
+          }
+        ]
+      }
+    })
+
+    if (!relations) {
+      relations = []
+    }
+    if (!properties) {
+      properties = []
+    }
+
+    return [...properties, ...relations]
+  }
+
+  private snapshotIndexes(values: Options): SnapshotIndexInfo[] {
+    return Object.entries(values.showProperties).map(([key, value]) => {
+      return {
+        indexName: key,
+        columnName: key,
+        table: values.tableName,
+      }
+    })
+  }
+
+  private getFkType(relation: Relationship<any>): any {
+    const entity = this.get(relation.entity() as any)
+    if (!entity) {
+      return 'unknown'
+    }
+
+    return entity.showProperties[this.getFkKey(relation)].type.name
+  }
+
+  /**
+   * If fkKey is null, return the primary key of the entity
+   * @private
+   * @param relationShip
+   */
+  private getFkKey(relationShip: Relationship<any>): string | number {
+    // se for nullable, deverá retornar o primary key da entidade target
+    if (typeof relationShip.fkKey === 'undefined') {
+      const entity = this.entities.get(relationShip.entity() as any);
+      const property = Object.entries(entity!.showProperties).find(([key, value]) => value.options.isPrimary === true);
+      if (!property) {
+        throw new Error(`Entity ${entity!.tableName} does not have a primary key`);
+      }
+
+      return property[0];
+    }
+
+    // se o fkKey é uma função, ele retornará a propriedade da entidade que é a chave estrangeira
+    // precisamos pegar o nome dessa propriedade
+    if (typeof relationShip.fkKey === 'string') {
+      return relationShip.fkKey;
+    }
+
+    const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
+    return match ? match.groups!.propriedade : '';
+  }
+}

package/src/domain/reference.ts

@@ -0,0 +1,5 @@
+export class Reference<T> {
+  constructor(private entity: T) {
+    console.log('Reference constructor')
+  }
+}

package/src/driver/driver.interface.ts

@@ -0,0 +1,331 @@
+import { PropertyOptions } from '../decorators/property.decorator';
+import { Collection } from '../domain/collection';
+import { Reference } from '../domain/reference';
+
+export interface DriverInterface {
+  connectionString: string;
+  executeStatement(statement: Statement<any>): Promise<{ query: any, startTime: number, sql: string }>;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  executeSql(s: string): Promise<any>;
+  snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
+
+  getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
+  getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo) : string;
+  getCreateIndex(index: { name: string; properties?: string[] }, schema: string | undefined, tableName: string): string;
+  getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void;
+  getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string): void;
+
+  getDropIndex(index: {name: string; properties?: string[]}, schema: string | undefined, tableName: string): string;
+
+  getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+
+  getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+
+  getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+
+  getDropConstraint(param: {name: string}, schema: string | undefined, tableName: string): string;
+
+  getAddUniqueConstraint(schema: string | undefined, tableName: string, colName: string): string;
+
+  getAlterTableDropNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+
+  getAlterTableDropNotNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+
+  startTransaction(): Promise<void>;
+  commitTransaction(): Promise<void>;
+  rollbackTransaction(): Promise<void>;
+}
+
+export type SnapshotConstraintInfo = {
+  indexName: string;
+  consDef: string;
+  type: string;
+}
+
+export interface ConnectionSettings<T extends DriverInterface = DriverInterface> {
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  database?: string;
+  connectionString?: string;
+  ssl?: boolean;
+  driver: T;
+  entities?: Function[] | string;
+  migrationPath?: string;
+}
+
+export type ConditionOperators<T, C> = {
+  $ne?: T;
+  $in?: T[];
+  $nin?: T[];
+  $like?: string;
+  $gt?: T;
+  $gte?: T;
+  $lt?: T;
+  $lte?: T;
+
+  $and?: Condition<C>[];
+  $or?: Condition<C>[];
+  // adicione aqui os demais operadores que precisar
+};
+
+export type Condition<T> = {
+  [P in keyof T]?: T[P] | ConditionOperators<T[P], T>;
+};
+
+export type InstanceOf<T> = {
+  [key in keyof T]: T[key]
+};
+
+export type JoinStatement<T> = {
+  type: 'INNER' | 'LEFT' | 'RIGHT';
+  originalEntity?: Function;
+  originTable: string;
+  originSchema: string;
+  originAlias: string;
+  joinTable: string;
+  joinSchema: string;
+  joinAlias: string;
+  joinEntity?: Function;
+  joinWhere?: string;
+  joinProperty: string;
+  on: string;
+  propertyKey: string | symbol;
+};
+
+export type Statement<T> = {
+  statement?: 'select' | 'insert' | 'update' | 'delete';
+  table?: string;
+  alias?: string;
+  columns?: Array<keyof T>;
+  join?: JoinStatement<T>[];
+  where?: string;
+  values?: any;
+  groupBy?: string[];
+  orderBy?: string[];
+  limit?: number;
+  offset?: number;
+}
+
+interface SnapshotColumnInfo {
+  table_catalog: string;
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  ordinal_position: number;
+  column_default: string | null;
+  is_nullable: string;
+  data_type: string;
+  character_maximum_length: number | null;
+  character_octet_length: number | null;
+  numeric_precision: number | null;
+  numeric_scale: number | null;
+  datetime_precision: number | null;
+  character_set_name: string | null;
+  collation_name: string | null;
+  column_type: string;
+  column_key: string;
+  extra: string;
+  privileges: string;
+  column_comment: string;
+}
+
+export type SnapshotTable = {
+  tableName: string;
+  schema?: string;
+  columns: ColumnsInfo[];
+  indexes: SnapshotIndexInfo[];
+  foreignKeys?: ForeignKeyInfo[];
+}
+
+export type SnapshotIndexInfo = {
+  table: string;
+  indexName: string;
+  columnName: string;
+}
+
+export type ForeignKeyInfo = {
+  referencedTableName: string;
+  referencedColumnName: string;
+}
+
+export type ColumnsInfo = {
+  name: string;
+  type: string;
+  nullable?: boolean;
+  default?: string | null;
+  primary?: boolean;
+  unique?: boolean;
+  length?: number;
+  foreignKeys?: ForeignKeyInfo[];
+}
+
+export type SqlActionType = 'CREATE' | 'DELETE' | 'ALTER' | 'INDEX';
+
+export type ColDiff = {
+  actionType: SqlActionType;
+  colName: string;
+  colType?: string;
+  colLength?: number;
+  indexTables?: { name: string, properties?: string[] }[];
+  colChanges?: {
+    default?: string | null;
+    primary?: boolean;
+    unique?: boolean;
+    nullable?: boolean;
+    foreignKeys?: ForeignKeyInfo[];
+  };
+}
+
+export type TableDiff = {
+  tableName: string;
+  schema?: string;
+  newTable?: boolean;
+  colDiffs: ColDiff[];
+}
+
+export declare const PrimaryKeyType: unique symbol;
+export declare const PrimaryKeyProp: unique symbol;
+type ReadonlyPrimary<T> = T extends any[] ? Readonly<T> : T;
+export type Primary<T> = T extends {
+  [PrimaryKeyType]?: infer PK;
+} ? ReadonlyPrimary<PK> : T extends {
+  _id?: infer PK;
+} ? ReadonlyPrimary<PK> | string : T extends {
+  uuid?: infer PK;
+} ? ReadonlyPrimary<PK> : T extends {
+  id?: infer PK;
+} ? ReadonlyPrimary<PK> : never;
+export type PrimaryProperty<T> = T extends {
+  [PrimaryKeyProp]?: infer PK;
+} ? PK : T extends {
+  _id?: any;
+} ? '_id' | string : T extends {
+  uuid?: any;
+} ? 'uuid' : T extends {
+  id?: any;
+} ? 'id' : never;
+export type IPrimaryKeyValue = number | string | bigint | Date | {
+  toHexString(): string;
+};
+export type IPrimaryKey<T extends IPrimaryKeyValue = IPrimaryKeyValue> = T;
+export type OperatorMap<T> = {
+  $and?: Query<T>[];
+  $or?: Query<T>[];
+  $eq?: ExpandScalar<T> | ExpandScalar<T>[];
+  $ne?: ExpandScalar<T>;
+  $in?: ExpandScalar<T>[];
+  $nin?: ExpandScalar<T>[];
+  $not?: Query<T>;
+  $gt?: ExpandScalar<T>;
+  $gte?: ExpandScalar<T>;
+  $lt?: ExpandScalar<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 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);
+type ExpandObject<T> = T extends object ? T extends Scalar ? never : {
+  -readonly [K in keyof T as ExcludeFunctions<T, K>]?: Query<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null;
+} : never;
+export type EntityProps<T> = {
+  -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>;
+export type FilterValue2<T> = T | ExpandScalar<T> | Primary<T>;
+export type FilterValue<T> = OperatorMap<FilterValue2<T>> | FilterValue2<T> | FilterValue2<T>[] | null;
+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 Relationship<T> = {
+  isRelation?: boolean;
+  relation: 'one-to-many' | 'many-to-one';
+  type: Function;
+  fkKey?: (string & keyof T) | ((e: T) => any);
+  entity: () => EntityName<T>;
+  originalEntity?: EntityName<T>;
+  propertyKey: string | symbol;
+} & Partial<PropertyOptions>;
+
+export type Cast<T, R> = T extends R ? T : R;
+export type IsUnknown<T> = T extends unknown ? unknown extends T ? true : never : never;
+export type IdentifiedReference<T, PK extends keyof T | unknown = PrimaryProperty<T>> = true extends IsUnknown<PK> ? Reference<T> : ({
+  [K in Cast<PK, keyof T>]: T[K];
+} & Reference<T>);
+export type Ref<T, PK extends keyof T | unknown = PrimaryProperty<T>> = IdentifiedReference<T, PK>;
+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 Ref<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 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 {
+  ASC = "ASC",
+  ASC_NULLS_LAST = "ASC NULLS LAST",
+  ASC_NULLS_FIRST = "ASC NULLS FIRST",
+  DESC = "DESC",
+  DESC_NULLS_LAST = "DESC NULLS LAST",
+  DESC_NULLS_FIRST = "DESC NULLS FIRST",
+  asc = "asc",
+  asc_nulls_last = "asc nulls last",
+  asc_nulls_first = "asc nulls first",
+  desc = "desc",
+  desc_nulls_last = "desc nulls last",
+  desc_nulls_first = "desc nulls first"
+}
+export declare enum QueryOrderNumeric {
+  ASC = 1,
+  DESC = -1
+}
+export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder;
+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 interface FindOptions<T, P extends string = never> {
+  // populate?: readonly AutoPath<T, P>[] | boolean;
+  orderBy?: (QueryOrderMap<T> & {
+    0?: never;
+  }) | QueryOrderMap<T>[];
+  // cache?: boolean | number | [string, number];
+  limit?: number;
+  offset?: number;
+  fields?: readonly EntityField<T, P>[];
+}
+export type FindOneOption<T, P extends string = never> = Omit<FindOptions<T, P>, 'limit'|'offset'>