metal-orm 1.0.8 → 1.0.9

package/src/decorators/entity.ts

@@ -0,0 +1,36 @@
+import { TableHooks } from '../schema/table.js';
+import { setEntityTableName } from '../orm/entity-metadata.js';
+
+export interface EntityOptions {
+  tableName?: string;
+  hooks?: TableHooks;
+}
+
+const toSnakeCase = (value: string): string => {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^a-z0-9_]+/gi, '_')
+    .replace(/__+/g, '_')
+    .replace(/^_|_$/g, '')
+    .toLowerCase();
+};
+
+const deriveTableNameFromConstructor = (ctor: Function): string => {
+  const fallback = 'unknown';
+  const rawName = ctor.name || fallback;
+  const strippedName = rawName.replace(/Entity$/i, '');
+  const normalized = toSnakeCase(strippedName || rawName);
+  if (!normalized) {
+    return fallback;
+  }
+  return normalized.endsWith('s') ? normalized : `${normalized}s`;
+};
+
+export function Entity(options: EntityOptions = {}) {
+  const decorator = <T extends new (...args: any[]) => any>(value: T) => {
+    const tableName = options.tableName ?? deriveTableNameFromConstructor(value);
+    setEntityTableName(value, tableName, options.hooks);
+    return value;
+  };
+  return decorator as unknown as ClassDecorator;
+}

package/src/decorators/index.ts

@@ -0,0 +1,4 @@
+export * from './entity.js';
+export * from './column.js';
+export * from './relations.js';
+export * from './bootstrap.js';

package/src/decorators/relations.ts

@@ -0,0 +1,107 @@
+import { CascadeMode, RelationKinds } from '../schema/relation.js';
+import {
+  addRelationMetadata,
+  EntityConstructor,
+  EntityOrTableTargetResolver,
+  RelationMetadata
+} from '../orm/entity-metadata.js';
+
+interface BaseRelationOptions {
+  target: EntityOrTableTargetResolver;
+  cascade?: CascadeMode;
+  localKey?: string;
+}
+
+export interface HasManyOptions extends BaseRelationOptions {
+  foreignKey: string;
+}
+
+export interface BelongsToOptions extends BaseRelationOptions {
+  foreignKey: string;
+}
+
+export interface BelongsToManyOptions {
+  target: EntityOrTableTargetResolver;
+  pivotTable: EntityOrTableTargetResolver;
+  pivotForeignKeyToRoot: string;
+  pivotForeignKeyToTarget: string;
+  localKey?: string;
+  targetKey?: string;
+  pivotPrimaryKey?: string;
+  defaultPivotColumns?: string[];
+  cascade?: CascadeMode;
+}
+
+const normalizePropertyName = (name: string | symbol): string => {
+  if (typeof name === 'symbol') {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+
+const resolveConstructor = (instanceOrCtor: unknown): EntityConstructor | undefined => {
+  if (typeof instanceOrCtor === 'function') {
+    return instanceOrCtor as EntityConstructor;
+  }
+  if (instanceOrCtor && typeof (instanceOrCtor as any).constructor === 'function') {
+    return (instanceOrCtor as any).constructor as EntityConstructor;
+  }
+  return undefined;
+};
+
+const registerRelation = (ctor: EntityConstructor, propertyName: string, metadata: RelationMetadata): void => {
+  addRelationMetadata(ctor, propertyName, metadata);
+};
+
+const createFieldDecorator = (
+  metadataFactory: (propertyName: string) => RelationMetadata
+) => {
+  const decorator = (target: object, propertyKey: string | symbol) => {
+    const propertyName = normalizePropertyName(propertyKey);
+    const ctor = resolveConstructor(target);
+    if (!ctor) {
+      throw new Error('Unable to resolve constructor when registering relation metadata');
+    }
+    registerRelation(ctor, propertyName, metadataFactory(propertyName));
+  };
+
+  return decorator as PropertyDecorator;
+};
+
+export function HasMany(options: HasManyOptions) {
+  return createFieldDecorator(propertyName => ({
+    kind: RelationKinds.HasMany,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+
+export function BelongsTo(options: BelongsToOptions) {
+  return createFieldDecorator(propertyName => ({
+    kind: RelationKinds.BelongsTo,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+
+export function BelongsToMany(options: BelongsToManyOptions) {
+  return createFieldDecorator(propertyName => ({
+    kind: RelationKinds.BelongsToMany,
+    propertyKey: propertyName,
+    target: options.target,
+    pivotTable: options.pivotTable,
+    pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
+    pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
+    localKey: options.localKey,
+    targetKey: options.targetKey,
+    pivotPrimaryKey: options.pivotPrimaryKey,
+    defaultPivotColumns: options.defaultPivotColumns,
+    cascade: options.cascade
+  }));
+}

package/src/global.d.ts

@@ -0,0 +1 @@
+declare module 'tsconfig-paths/register';

package/src/index.ts

@@ -1,23 +1,23 @@
 
-export * from './schema/table';
-export * from './schema/column';
-export * from './schema/relation';
-export * from './schema/types';
-export * from './builder/select';
-export * from './builder/insert';
-export * from './builder/update';
-export * from './builder/delete';
-export * from './ast/expression';
-export * from './dialect/mysql';
-export * from './dialect/mssql';
-export * from './dialect/sqlite';
-export * from './runtime/als';
-export * from './runtime/hydration';
-export * from './codegen/typescript';
-export * from './runtime/orm-context';
-export * from './runtime/entity';
-export * from './runtime/lazy-batch';
-export * from './runtime/relations/has-many';
-export * from './runtime/relations/belongs-to';
-export * from './runtime/relations/many-to-many';
-export * from './runtime/execute';
+export * from './schema/table.js';
+export * from './schema/column.js';
+export * from './schema/relation.js';
+export * from './schema/types.js';
+export * from './query-builder/select.js';
+export * from './query-builder/insert.js';
+export * from './query-builder/update.js';
+export * from './query-builder/delete.js';
+export * from './core/ast/expression.js';
+export * from './core/dialect/mysql/index.js';
+export * from './core/dialect/mssql/index.js';
+export * from './core/dialect/sqlite/index.js';
+export * from './orm/als.js';
+export * from './orm/hydration.js';
+export * from './codegen/typescript.js';
+export * from './orm/orm-context.js';
+export * from './orm/entity.js';
+export * from './orm/lazy-batch.js';
+export * from './orm/relations/has-many.js';
+export * from './orm/relations/belongs-to.js';
+export * from './orm/relations/many-to-many.js';
+export * from './orm/execute.js';

package/src/orm/db-executor.ts

@@ -0,0 +1,11 @@
+export type QueryResult = {
+  columns: string[];
+  values: unknown[][];
+};
+
+export interface DbExecutor {
+  executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
+  beginTransaction?(): Promise<void>;
+  commitTransaction?(): Promise<void>;
+  rollbackTransaction?(): Promise<void>;
+}

package/src/orm/domain-event-bus.ts

@@ -0,0 +1,52 @@
+import type { HasDomainEvents, TrackedEntity } from './runtime-types.js';
+
+export type DomainEventHandler<Context> = (event: any, ctx: Context) => Promise<void> | void;
+
+export class DomainEventBus<Context> {
+  private readonly handlers = new Map<string, DomainEventHandler<Context>[]>();
+
+  constructor(initialHandlers?: Record<string, DomainEventHandler<Context>[]>) {
+    const handlers = initialHandlers ?? {};
+    Object.entries(handlers).forEach(([name, list]) => {
+      this.handlers.set(name, [...list]);
+    });
+  }
+
+  register(name: string, handler: DomainEventHandler<Context>): void {
+    const existing = this.handlers.get(name) ?? [];
+    existing.push(handler);
+    this.handlers.set(name, existing);
+  }
+
+  async dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void> {
+    for (const tracked of trackedEntities) {
+      const entity = tracked.entity as HasDomainEvents;
+      if (!entity.domainEvents || !entity.domainEvents.length) continue;
+
+      for (const event of entity.domainEvents) {
+        const eventName = this.getEventName(event);
+        const handlers = this.handlers.get(eventName);
+        if (!handlers) continue;
+
+        for (const handler of handlers) {
+          await handler(event, ctx);
+        }
+      }
+
+      entity.domainEvents = [];
+    }
+  }
+
+  private getEventName(event: any): string {
+    if (!event) return 'Unknown';
+    if (typeof event === 'string') return event;
+    return event.constructor?.name ?? 'Unknown';
+  }
+}
+
+export const addDomainEvent = (entity: HasDomainEvents, event: any): void => {
+  if (!entity.domainEvents) {
+    entity.domainEvents = [];
+  }
+  entity.domainEvents.push(event);
+};

package/src/{runtime → orm}/entity-meta.ts

@@ -1,52 +1,52 @@
-import { TableDef } from '../schema/table';
-import { OrmContext } from './orm-context';
-import { RelationMap } from '../schema/types';
-
-export const ENTITY_META = Symbol('EntityMeta');
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-export interface EntityMeta<TTable extends TableDef> {
-  ctx: OrmContext;
-  table: TTable;
-  lazyRelations: (keyof RelationMap<TTable>)[];
-  relationCache: Map<string, Promise<any>>;
-  relationHydration: Map<string, Map<string, any>>;
-  relationWrappers: Map<string, unknown>;
-}
-
-export const getHydrationRows = <TTable extends TableDef>(
-  meta: EntityMeta<TTable>,
-  relationName: string,
-  key: unknown
-): Record<string, any>[] | undefined => {
-  const map = meta.relationHydration.get(relationName);
-  if (!map) return undefined;
-  const rows = map.get(toKey(key));
-  if (!rows) return undefined;
-  return Array.isArray(rows) ? rows : undefined;
-};
-
-export const getHydrationRecord = <TTable extends TableDef>(
-  meta: EntityMeta<TTable>,
-  relationName: string,
-  key: unknown
-): Record<string, any> | undefined => {
-  const map = meta.relationHydration.get(relationName);
-  if (!map) return undefined;
-  const value = map.get(toKey(key));
-  if (!value) return undefined;
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-  return value;
-};
-
-export const getEntityMeta = <TTable extends TableDef>(entity: any): EntityMeta<TTable> | undefined => {
-  if (!entity || typeof entity !== 'object') return undefined;
-  return (entity as any)[ENTITY_META];
-};
-
-export const hasEntityMeta = (entity: any): entity is { [ENTITY_META]: EntityMeta<TableDef> } => {
-  return Boolean(getEntityMeta(entity));
-};
+import { TableDef } from '../schema/table.js';
+import { OrmContext } from './orm-context.js';
+import { RelationMap } from '../schema/types.js';
+
+export const ENTITY_META = Symbol('EntityMeta');
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+export interface EntityMeta<TTable extends TableDef> {
+  ctx: OrmContext;
+  table: TTable;
+  lazyRelations: (keyof RelationMap<TTable>)[];
+  relationCache: Map<string, Promise<any>>;
+  relationHydration: Map<string, Map<string, any>>;
+  relationWrappers: Map<string, unknown>;
+}
+
+export const getHydrationRows = <TTable extends TableDef>(
+  meta: EntityMeta<TTable>,
+  relationName: string,
+  key: unknown
+): Record<string, any>[] | undefined => {
+  const map = meta.relationHydration.get(relationName);
+  if (!map) return undefined;
+  const rows = map.get(toKey(key));
+  if (!rows) return undefined;
+  return Array.isArray(rows) ? rows : undefined;
+};
+
+export const getHydrationRecord = <TTable extends TableDef>(
+  meta: EntityMeta<TTable>,
+  relationName: string,
+  key: unknown
+): Record<string, any> | undefined => {
+  const map = meta.relationHydration.get(relationName);
+  if (!map) return undefined;
+  const value = map.get(toKey(key));
+  if (!value) return undefined;
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+};
+
+export const getEntityMeta = <TTable extends TableDef>(entity: any): EntityMeta<TTable> | undefined => {
+  if (!entity || typeof entity !== 'object') return undefined;
+  return (entity as any)[ENTITY_META];
+};
+
+export const hasEntityMeta = (entity: any): entity is { [ENTITY_META]: EntityMeta<TableDef> } => {
+  return Boolean(getEntityMeta(entity));
+};

package/src/orm/entity-metadata.ts

@@ -0,0 +1,140 @@
+import { ColumnType, ColumnDef } from '../schema/column.js';
+import { defineTable, TableDef, TableHooks } from '../schema/table.js';
+import { CascadeMode, RelationKinds } from '../schema/relation.js';
+
+export type EntityConstructor = new (...args: any[]) => any;
+export type EntityOrTableTarget = EntityConstructor | TableDef;
+export type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
+
+export interface ColumnDefLike {
+  type: ColumnType;
+  args?: ColumnDef['args'];
+  primary?: boolean;
+  notNull?: boolean;
+}
+
+interface BaseRelationMetadata {
+  propertyKey: string;
+  target: EntityOrTableTargetResolver;
+  cascade?: CascadeMode;
+}
+
+export interface HasManyRelationMetadata extends BaseRelationMetadata {
+  kind: typeof RelationKinds.HasMany;
+  foreignKey: string;
+  localKey?: string;
+}
+
+export interface BelongsToRelationMetadata extends BaseRelationMetadata {
+  kind: typeof RelationKinds.BelongsTo;
+  foreignKey: string;
+  localKey?: string;
+}
+
+export interface BelongsToManyRelationMetadata extends BaseRelationMetadata {
+  kind: typeof RelationKinds.BelongsToMany;
+  pivotTable: EntityOrTableTargetResolver;
+  pivotForeignKeyToRoot: string;
+  pivotForeignKeyToTarget: string;
+  localKey?: string;
+  targetKey?: string;
+  pivotPrimaryKey?: string;
+  defaultPivotColumns?: string[];
+}
+
+export type RelationMetadata =
+  | HasManyRelationMetadata
+  | BelongsToRelationMetadata
+  | BelongsToManyRelationMetadata;
+
+export interface EntityMetadata {
+  target: EntityConstructor;
+  tableName: string;
+  columns: Record<string, ColumnDefLike>;
+  relations: Record<string, RelationMetadata>;
+  hooks?: TableHooks;
+  table?: TableDef;
+}
+
+const metadataMap = new Map<EntityConstructor, EntityMetadata>();
+
+export const registerEntityMetadata = (meta: EntityMetadata): void => {
+  metadataMap.set(meta.target, meta);
+};
+
+export const ensureEntityMetadata = (target: EntityConstructor): EntityMetadata => {
+  let meta = metadataMap.get(target);
+  if (!meta) {
+    meta = {
+      target,
+      tableName: target.name || 'unknown',
+      columns: {},
+      relations: {}
+    };
+    metadataMap.set(target, meta);
+  }
+  return meta;
+};
+
+export const getEntityMetadata = (target: EntityConstructor): EntityMetadata | undefined => {
+  return metadataMap.get(target);
+};
+
+export const getAllEntityMetadata = (): EntityMetadata[] => {
+  return Array.from(metadataMap.values());
+};
+
+export const clearEntityMetadata = (): void => {
+  metadataMap.clear();
+};
+
+export const addColumnMetadata = (
+  target: EntityConstructor,
+  propertyKey: string,
+  column: ColumnDefLike
+): void => {
+  const meta = ensureEntityMetadata(target);
+  meta.columns[propertyKey] = { ...column };
+};
+
+export const addRelationMetadata = (
+  target: EntityConstructor,
+  propertyKey: string,
+  relation: RelationMetadata
+): void => {
+  const meta = ensureEntityMetadata(target);
+  meta.relations[propertyKey] = relation;
+};
+
+export const setEntityTableName = (
+  target: EntityConstructor,
+  tableName: string,
+  hooks?: TableHooks
+): void => {
+  const meta = ensureEntityMetadata(target);
+  if (tableName && tableName.length > 0) {
+    meta.tableName = tableName;
+  }
+  if (hooks) {
+    meta.hooks = hooks;
+  }
+};
+
+export const buildTableDef = (meta: EntityMetadata): TableDef => {
+  if (meta.table) {
+    return meta.table;
+  }
+
+  const columns = Object.entries(meta.columns).reduce<Record<string, ColumnDef>>((acc, [key, def]) => {
+    acc[key] = {
+      ...def,
+      name: key,
+      table: meta.tableName
+    };
+    return acc;
+  }, {});
+
+  const table = defineTable(meta.tableName, columns, {}, meta.hooks);
+  meta.table = table;
+  return table;
+};