@cheetah.js/orm 0.1.8 → 0.1.10

package/src/driver/driver.interface.ts

@@ -0,0 +1,340 @@
+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;
+  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>;
+}
+
+// @ts-ignore
+export type ValueOrInstance<T> = T extends ValueObject<any, any> ? T | T['value'] : NonNullable<T>;
+
+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;
+  autoIncrement?: 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;
+    autoIncrement?: 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 ? 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)[] ? 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>;
+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> = ValueOrInstance<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> = {
+  // @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, '*'>;
+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'>

package/src/driver/pg-driver.ts

@@ -0,0 +1,310 @@
+import {
+  ColDiff,
+  ConnectionSettings,
+  DriverInterface, ForeignKeyInfo,
+  SnapshotConstraintInfo,
+  SnapshotIndexInfo,
+  SnapshotTable,
+  Statement,
+} from './driver.interface';
+import { Client } from 'pg'
+
+export class PgDriver implements DriverInterface {
+  connectionString: string;
+
+  private client: Client;
+
+  constructor(options: ConnectionSettings) {
+    if (options.connectionString) {
+      this.connectionString = options.connectionString;
+    } else {
+      const {host, port, username, password, database} = options;
+      this.connectionString = `postgres://${username}:${password}@${host}:${port}/${database}`;
+    }
+
+    this.client = new Client({
+      connectionString: this.connectionString,
+    })
+  }
+
+  getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]) {
+    return `CREATE TABLE "${schema}"."${tableName}" (${creates.map(colDiff => {
+      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';
+      }
+
+      if (colDiff.colChanges?.primary) {
+        sql += ' PRIMARY KEY';
+      }
+
+      if (colDiff.colChanges?.unique) {
+        sql += ' UNIQUE';
+      }
+
+      if (colDiff.colChanges?.default) {
+        sql += ` DEFAULT ${colDiff.colChanges.default}`;
+      }
+
+      return sql;
+    })});`;
+  }
+  getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo) {
+    return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${tableName}_${colDiff.colName}_fk" FOREIGN KEY ("${colDiff.colName}") REFERENCES "${fk.referencedTableName}" ("${fk.referencedColumnName}");`;
+  }
+  getCreateIndex(index: { name: string; properties: string[] }, schema: string | undefined, tableName: string) {
+    return `CREATE INDEX "${index.name}" ON "${schema}"."${tableName}" (${index.properties.map(prop => `"${prop}"`).join(', ')});`;
+  }
+  getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void{
+    let sql = `ALTER TABLE "${schema}"."${tableName}" ADD COLUMN "${colName}" ${colDiff.colType}${(colDiff.colLength ? `(${colDiff.colLength})` : '')}`
+
+    if (!colDiff.colChanges?.nullable) {
+      sql += ' NOT NULL';
+    }
+    if (colDiff.colChanges?.primary) {
+      sql += ' PRIMARY KEY';
+    }
+    if (colDiff.colChanges?.unique) {
+      sql += ' UNIQUE';
+    }
+    if (colDiff.colChanges?.default) {
+      sql += ` DEFAULT ${colDiff.colChanges.default}`;
+    }
+    colDiffInstructions.push(sql.concat(';'));
+
+    if (colDiff.colChanges?.foreignKeys) {
+      colDiff.colChanges.foreignKeys.forEach(fk => {
+        colDiffInstructions.push(`ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${tableName}_${colName}_fk" FOREIGN KEY ("${colName}") REFERENCES "${fk.referencedTableName}" ("${fk.referencedColumnName}");`);
+      });
+    }
+  }
+  getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string) {
+    colDiffInstructions.push(`ALTER TABLE "${schema}"."${tableName}" DROP COLUMN IF EXISTS "${colName}";`);
+  }
+  getDropIndex(index: { name: string; properties?: string[] }, schema: string | undefined, tableName: string) {
+    return `DROP INDEX "${index.name}" ON "${schema}"."${tableName}";`;
+  }
+  getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string {
+    return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" TYPE ${colDiff.colType}${(colDiff.colLength ? `(${colDiff.colLength})` : '')};`;
+  }
+  getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string {
+    return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" SET DEFAULT ${colDiff.colChanges!.default};`;
+  }
+  getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string {
+    return `ALTER TABLE "${schema}"."${tableName}" ADD PRIMARY KEY ("${colName}");`
+  }
+  getDropConstraint(param: { name: string }, schema: string | undefined, tableName: string): string {
+    return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${param.name}";`;
+  }
+  getAddUniqueConstraint(schema: string | undefined, tableName: string, colName: string): string {
+    return `ALTER TABLE "${schema}"."${tableName}" ADD UNIQUE ("${colName}");`
+  }
+  getAlterTableDropNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string {
+    return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" DROP NOT NULL;`
+  }
+  getAlterTableDropNotNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string {
+    return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" SET NOT NULL;`;
+  }
+
+  async startTransaction(): Promise<void> {
+    await this.client.query('BEGIN;');
+  }
+
+  async commitTransaction(): Promise<void> {
+    await this.client.query('COMMIT;');
+  }
+
+  async rollbackTransaction(): Promise<void> {
+    await this.client.query('ROLLBACK;');
+  }
+
+  async executeStatement(statement: Statement<any>): Promise<{ query: any, startTime: number, sql: string }>{
+    let {statement: statementType, table, columns, where, limit, alias} = statement;
+    let sql = '';
+
+    switch (statementType) {
+      case 'select':
+        sql = `SELECT ${columns ? columns.join(', ') : '*'} FROM ${table} ${alias}`;
+        break;
+      case 'insert': // TODO: Tratar corretamente os valores string, number
+        const fields = Object.keys(statement.values).map(v => `"${v}"`).join(', ');
+        const values = Object.values(statement.values).map(value => this.toDatabaseValue(value)).join(', ');
+
+        sql = `INSERT INTO ${table} (${fields}) VALUES (${values}) RETURNING ${statement.columns!.join(', ').replaceAll(`${alias}.`, '')}`;
+        break;
+      case 'update':
+        sql = `UPDATE ${table} as ${alias} SET ${Object.entries(statement.values).map(([key, value]) => `${key} = '${value}'`).join(', ')}`;
+        break;
+      case 'delete':
+        break;
+    }
+
+    if (statement.join) {
+      statement.join.forEach(join => {
+        sql += ` ${join.type} JOIN ${join.joinSchema}.${join.joinTable} ${join.joinAlias} ON ${join.on}`;
+      });
+    }
+
+    if (statementType !== 'insert') {
+      if (where) {
+        sql += ` WHERE ${where}`;
+      }
+
+      if (statement.orderBy) {
+        sql += ` ORDER BY ${statement.orderBy.join(', ')}`;
+      }
+
+      if (statement.offset) {
+        sql += ` OFFSET ${statement.offset}`;
+      }
+
+      if (limit) {
+        sql += ` LIMIT ${statement.limit}`;
+      }
+    }
+
+    const startTime = Date.now();
+    return {
+      query: await this.client.query(sql),
+      startTime,
+      sql
+    };
+  }
+
+
+  connect(): Promise<void> {
+    return this.client.connect()
+  }
+
+  disconnect(): Promise<void> {
+    return this.client.end()
+  }
+
+  executeSql(s: string) {
+    return this.client.query(s)
+  }
+
+  async snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined> {
+    const schema = (options && options.schema) || 'public';
+    const sql = `SELECT * FROM information_schema.columns WHERE table_name = '${tableName}' AND table_schema = '${schema}'`;
+    const result = await this.client.query(sql);
+
+    if (!result.rows || result.rows.length === 0) {
+      return;
+    }
+
+    const indexes = await this.index(tableName, options) || [];
+    const constraints = await this.constraints(tableName, options) || [];
+
+    return {
+      tableName,
+      schema,
+      indexes,
+      columns: result.rows.map(row => {
+        // console.log(this.getForeignKeys(constraints, row), row.column_name)
+        return {
+          default: row.column_default,
+          length: row.character_maximum_length || row.numeric_precision || row.datetime_precision,
+          name: row.column_name,
+          nullable: row.is_nullable === 'YES',
+          primary: constraints.some(c => c.type === 'PRIMARY KEY' && c.consDef.includes(row.column_name)),
+          unique: constraints.some(c => (c.type === 'UNIQUE' || c.type === 'PRIMARY KEY') && c.consDef.includes(row.column_name)),
+          type: row.data_type,
+          foreignKeys: this.getForeignKeys(constraints, row)
+        }
+      })
+    }
+  }
+
+  private getForeignKeys(constraints: SnapshotConstraintInfo[], row: any) {
+    const name = row.column_name
+    return constraints.filter(c => c.type === 'FOREIGN KEY'  && c.consDef.match(new RegExp(`FOREIGN KEY \\("${row.column_name}"\\)`))).map(c => {
+      const filter = c.consDef.match(/REFERENCES\s+"([^"]+)"\s*\(([^)]+)\)/);
+
+      if (!filter) throw new Error('Invalid constraint definition');
+
+      return {
+        referencedColumnName: filter[2].split(',')[0].trim(),
+        referencedTableName: filter[1],
+      }
+    });
+  }
+
+  async index(tableName: string, options: any): Promise<SnapshotIndexInfo[] | undefined> {
+    const schema = (options && options.schema) || 'public';
+    const result = await this.client.query(
+      `SELECT indexname AS index_name, indexdef AS column_name, tablename AS table_name
+       FROM pg_indexes
+       WHERE tablename = '${tableName}' AND schemaname = '${schema}'`
+    );
+
+    return result.rows.map(row => {
+      return {
+        table: tableName,
+        indexName: row.index_name,
+        columnName: row.column_name
+      }
+    });
+  }
+
+  async constraints(tableName: string, options: any): Promise<SnapshotConstraintInfo[] | undefined> {
+    const schema = (options && options.schema) || 'public';
+    const result = await this.client.query(
+      `SELECT 
+        conname AS index_name,
+        pg_get_constraintdef(pg_constraint.oid) as consdef,
+        CASE contype
+            WHEN 'c' THEN 'CHECK'
+            WHEN 'f' THEN 'FOREIGN KEY'
+            WHEN 'p' THEN 'PRIMARY KEY'
+            WHEN 'u' THEN 'UNIQUE'
+            WHEN 't' THEN 'TRIGGER'
+            WHEN 'x' THEN 'EXCLUSION'
+            ELSE 'UNKNOWN'
+            END AS constraint_type
+       FROM pg_constraint 
+       where conrelid =  (
+           SELECT oid
+           FROM pg_class
+           WHERE relname = '${tableName}'
+             AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '${schema}')
+       )
+         AND conkey @> ARRAY(
+           SELECT attnum
+    FROM pg_attribute
+    WHERE attrelid = conrelid
+      AND attname = '${schema}'
+  )`
+    );
+
+    return result.rows.map(row => {
+      return {
+        indexName: row.index_name,
+        type: row.constraint_type,
+        consDef: row.consdef
+      }
+    });
+  }
+
+  private toDatabaseValue(value: unknown) {
+    if (value instanceof Date) {
+      return `'${value.toISOString()}'`;
+    }
+
+    switch (typeof value) {
+      case 'string':
+        return `'${value}'`;
+      case 'number':
+        return value;
+      case 'boolean':
+        return value;
+      case 'object':
+        return `'${JSON.stringify(value)}'`;
+      default:
+        return `'${value}'`;
+    }
+  }
+}

package/src/entry.ts

@@ -0,0 +1,6 @@
+import { Cheetah } from '@cheetah.js/core';
+import { Orm } from './orm';
+import { OrmService } from './orm.service';
+import { EntityStorage } from './domain/entities';
+
+export const CheetahOrm = new Cheetah({exports: [Orm, OrmService, EntityStorage]})

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './decorators/entity.decorator';
+export * from './decorators/property.decorator';
+export * from './decorators/primary-key.decorator';
+export * from './decorators/one-many.decorator';
+export * from './decorators/index.decorator';
+export * from './orm'
+export * from './orm.service'
+export * from './domain/base-entity'
+export * from './driver/pg-driver'
+export * from './utils'
+export * from './driver/driver.interface'
+export * from './entry'
+export * from './common/value-object'
+export * from './common/email.vo'
+export * from './common/uuid'