metal-orm 1.0.35 → 1.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/decorators/bootstrap.ts

@@ -119,16 +119,16 @@ export const bootstrapEntities = (): TableDef[] => {
   return metas.map(meta => meta.table!) as TableDef[];
 };
 
-export const getTableDefFromEntity = (ctor: EntityConstructor): TableDef | undefined => {
+export const getTableDefFromEntity = <TTable extends TableDef = TableDef>(ctor: EntityConstructor): TTable | undefined => {
   const meta = getEntityMetadata(ctor);
   if (!meta) return undefined;
   if (!meta.table) {
     bootstrapEntities();
   }
-  return meta.table;
+  return meta.table as TTable;
 };
 
-export const selectFromEntity = <TTable extends TableDef>(
+export const selectFromEntity = <TTable extends TableDef = TableDef>(
   ctor: EntityConstructor
 ): SelectQueryBuilder<any, TTable> => {
   const table = getTableDefFromEntity(ctor);

package/src/decorators/column.ts

@@ -18,9 +18,10 @@ export interface ColumnOptions {
   args?: ColumnDef['args'];
   notNull?: boolean;
   primary?: boolean;
+  tsType?: ColumnDef['tsType'];
 }
 
-export type ColumnInput = ColumnOptions | ColumnDef;
+export type ColumnInput = ColumnOptions | ColumnDef<any, any>;
 
 const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
   const asOptions = input as ColumnOptions;
@@ -30,6 +31,7 @@ const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
     args: asOptions.args ?? asDefinition.args,
     notNull: asOptions.notNull ?? asDefinition.notNull,
     primary: asOptions.primary ?? asDefinition.primary,
+    tsType: asDefinition.tsType ?? asOptions.tsType,
     unique: asDefinition.unique,
     default: asDefinition.default,
     autoIncrement: asDefinition.autoIncrement,

package/src/orm/entity-metadata.ts

@@ -6,7 +6,14 @@ export type EntityConstructor = new (...args: any[]) => any;
 export type EntityOrTableTarget = EntityConstructor | TableDef;
 export type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
 
-export type ColumnDefLike = Omit<ColumnDef, 'name' | 'table'>;
+export type ColumnDefLike<T extends ColumnDef = ColumnDef> = Omit<T, 'name' | 'table'>;
+
+type MaterializeColumns<TColumns extends Record<string, ColumnDefLike>> = {
+  [K in keyof TColumns]: ColumnDef<TColumns[K]['type'], TColumns[K]['tsType']> & Omit<
+    TColumns[K],
+    'name' | 'table' | 'type' | 'tsType'
+  > & { name: string; table: string };
+};
 
 interface BaseRelationMetadata {
   propertyKey: string;
@@ -49,13 +56,13 @@ export type RelationMetadata =
   | BelongsToRelationMetadata
   | BelongsToManyRelationMetadata;
 
-export interface EntityMetadata {
+export interface EntityMetadata<TColumns extends Record<string, ColumnDefLike> = Record<string, ColumnDefLike>> {
   target: EntityConstructor;
   tableName: string;
-  columns: Record<string, ColumnDefLike>;
+  columns: TColumns;
   relations: Record<string, RelationMetadata>;
   hooks?: TableHooks;
-  table?: TableDef;
+  table?: TableDef<MaterializeColumns<TColumns>>;
 }
 
 const metadataMap = new Map<EntityConstructor, EntityMetadata>();
@@ -96,7 +103,7 @@ export const addColumnMetadata = (
   column: ColumnDefLike
 ): void => {
   const meta = ensureEntityMetadata(target);
-  meta.columns[propertyKey] = { ...column };
+  (meta.columns as Record<string, ColumnDefLike>)[propertyKey] = { ...column };
 };
 
 export const addRelationMetadata = (
@@ -122,19 +129,19 @@ export const setEntityTableName = (
   }
 };
 
-export const buildTableDef = (meta: EntityMetadata): TableDef => {
+export const buildTableDef = <TColumns extends Record<string, ColumnDefLike>>(meta: EntityMetadata<TColumns>): TableDef<MaterializeColumns<TColumns>> => {
   if (meta.table) {
     return meta.table;
   }
 
-  const columns = Object.entries(meta.columns).reduce<Record<string, ColumnDef>>((acc, [key, def]) => {
-    acc[key] = {
+  const columns = Object.entries(meta.columns).reduce<MaterializeColumns<TColumns>>((acc, [key, def]) => {
+    (acc as any)[key] = {
       ...def,
       name: key,
       table: meta.tableName
     };
     return acc;
-  }, {});
+  }, {} as MaterializeColumns<TColumns>);
 
   const table = defineTable(meta.tableName, columns, {}, meta.hooks);
   meta.table = table;

package/src/orm/entity.ts

@@ -104,17 +104,20 @@ export const createEntityProxy = <
   return proxy;
 };
 
-export const createEntityFromRow = <TTable extends TableDef>(
+export const createEntityFromRow = <
+  TTable extends TableDef,
+  TResult extends EntityInstance<TTable> = EntityInstance<TTable>
+>(
   ctx: EntityContext,
   table: TTable,
   row: Record<string, any>,
   lazyRelations: (keyof RelationMap<TTable>)[] = []
-): EntityInstance<TTable> => {
+): TResult => {
   const pkName = findPrimaryKey(table);
   const pkValue = row[pkName];
   if (pkValue !== undefined && pkValue !== null) {
     const tracked = ctx.getEntity(table, pkValue);
-    if (tracked) return tracked;
+    if (tracked) return tracked as TResult;
   }
 
   const entity = createEntityProxy(ctx, table, row, lazyRelations);
@@ -124,7 +127,7 @@ export const createEntityFromRow = <TTable extends TableDef>(
     ctx.trackNew(table, entity);
   }
 
-  return entity;
+  return entity as TResult;
 };
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));

package/src/orm/orm-session.ts

@@ -185,24 +185,49 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     await this.unitOfWork.flush();
   }
 
-  async commit(): Promise<void> {
-    await runInTransaction(this.executor, async () => {
-      for (const interceptor of this.interceptors) {
-        await interceptor.beforeFlush?.(this);
-      }
+  private async flushWithHooks(): Promise<void> {
+    for (const interceptor of this.interceptors) {
+      await interceptor.beforeFlush?.(this);
+    }
+
+    await this.unitOfWork.flush();
+    await this.relationChanges.process();
+    await this.unitOfWork.flush();
 
-      await this.unitOfWork.flush();
-      await this.relationChanges.process();
-      await this.unitOfWork.flush();
+    for (const interceptor of this.interceptors) {
+      await interceptor.afterFlush?.(this);
+    }
+  }
 
-      for (const interceptor of this.interceptors) {
-        await interceptor.afterFlush?.(this);
-      }
+  async commit(): Promise<void> {
+    await runInTransaction(this.executor, async () => {
+      await this.flushWithHooks();
     });
 
     await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
   }
 
+  async transaction<T>(fn: (session: OrmSession<E>) => Promise<T>): Promise<T> {
+    // If the executor can't do transactions, just run and commit once.
+    if (!this.executor.beginTransaction) {
+      const result = await fn(this);
+      await this.commit();
+      return result;
+    }
+
+    await this.executor.beginTransaction();
+    try {
+      const result = await fn(this);
+      await this.flushWithHooks();
+      await this.executor.commitTransaction?.();
+      await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
+      return result;
+    } catch (err) {
+      await this.rollback();
+      throw err;
+    }
+  }
+
   async rollback(): Promise<void> {
     await this.executor.rollbackTransaction?.();
     this.unitOfWork.reset();

package/src/schema/types.ts

@@ -22,7 +22,7 @@ export type RelationTargetTable<TRel extends RelationDef> =
  * Maps a ColumnDef to its TypeScript type representation
  */
 export type ColumnToTs<T extends ColumnDef> =
-  T['tsType'] extends undefined
+  [unknown] extends [T['tsType']]
     ? T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
       T['type'] extends 'BIGINT' | 'bigint' ? number | bigint :
       T['type'] extends 'DECIMAL' | 'decimal' | 'FLOAT' | 'float' | 'DOUBLE' | 'double' ? number :