metal-orm 1.1.9 → 1.1.10

package/src/decorators/column-decorator.ts

@@ -1,96 +1,87 @@
-import { ColumnDef, ColumnType } from '../schema/column-types.js';
-import { ColumnDefLike } from '../orm/entity-metadata.js';
-import { getOrCreateMetadataBag } from './decorator-metadata.js';
-
-/**
- * Options for defining a column in an entity.
- */
-export interface ColumnOptions {
-  type: ColumnType;
-  args?: ColumnDef['args'];
-  dialectTypes?: ColumnDef['dialectTypes'];
-  notNull?: boolean;
-  primary?: boolean;
-  tsType?: ColumnDef['tsType'];
-  name?: string;
-}
-
-/**
- * Input type for column definitions, either as options object or direct ColumnDef.
- */
-export type ColumnInput = ColumnOptions | ColumnDef;
-
-const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
-  const asOptions = input as ColumnOptions;
-  const asDefinition = input as ColumnDef;
-  const column: ColumnDefLike = {
-    type: asOptions.type ?? asDefinition.type,
-    args: asOptions.args ?? asDefinition.args,
-    dialectTypes: asOptions.dialectTypes ?? asDefinition.dialectTypes,
-    notNull: asOptions.notNull ?? asDefinition.notNull,
-    primary: asOptions.primary ?? asDefinition.primary,
-    tsType: asDefinition.tsType ?? asOptions.tsType,
-    unique: asDefinition.unique,
-    default: asDefinition.default,
-    autoIncrement: asDefinition.autoIncrement,
-    generated: asDefinition.generated,
-    check: asDefinition.check,
-    references: asDefinition.references,
-    comment: asDefinition.comment,
-    name: asOptions.name ?? asDefinition.name
-  };
-
-  if (!column.type) {
-    throw new Error('Column decorator requires a column type');
-  }
-
-  return column;
-};
-
-const normalizePropertyName = (name: string | symbol): string => {
-  if (typeof name === 'symbol') {
-    return name.description ?? name.toString();
-  }
-  return name;
-};
-
-const registerColumnFromContext = (
-  context: ClassFieldDecoratorContext,
-  column: ColumnDefLike
-): void => {
-  if (!context.name) {
-    throw new Error('Column decorator requires a property name');
-  }
-  if (context.private) {
-    throw new Error('Column decorator does not support private fields');
-  }
-  const propertyName = normalizePropertyName(context.name);
-  const bag = getOrCreateMetadataBag(context);
-  if (!bag.columns.some(entry => entry.propertyName === propertyName)) {
-    bag.columns.push({ propertyName, column: { ...column } });
-  }
-};
-
-/**
- * Decorator to define a column on an entity property.
- * @param definition - The column definition or options.
- * @returns A property decorator that registers the column metadata.
- */
-export function Column(definition: ColumnInput) {
-  const normalized = normalizeColumnInput(definition);
-  return function (_value: unknown, context: ClassFieldDecoratorContext) {
-    registerColumnFromContext(context, normalized);
-  };
-}
-
-/**
- * Decorator to define a primary key column on an entity property.
- * Sets the primary flag to true and delegates to Column decorator.
- * @param definition - The column definition or options.
- * @returns A property decorator that registers the primary key column metadata.
- */
-export function PrimaryKey(definition: ColumnInput) {
-  const normalized = normalizeColumnInput(definition);
-  normalized.primary = true;
-  return Column(normalized);
-}
+import { ColumnDef, ColumnType } from '../schema/column-types.js';
+import { ColumnDefLike } from '../orm/entity-metadata.js';
+import { resolveFieldDecoratorInfo } from './decorator-metadata.js';
+
+/**
+ * Options for defining a column in an entity.
+ */
+export interface ColumnOptions {
+  type: ColumnType;
+  args?: ColumnDef['args'];
+  dialectTypes?: ColumnDef['dialectTypes'];
+  notNull?: boolean;
+  primary?: boolean;
+  tsType?: ColumnDef['tsType'];
+  name?: string;
+}
+
+/**
+ * Input type for column definitions, either as options object or direct ColumnDef.
+ */
+export type ColumnInput = ColumnOptions | ColumnDef;
+
+const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
+  const asOptions = input as ColumnOptions;
+  const asDefinition = input as ColumnDef;
+  const column: ColumnDefLike = {
+    type: asOptions.type ?? asDefinition.type,
+    args: asOptions.args ?? asDefinition.args,
+    dialectTypes: asOptions.dialectTypes ?? asDefinition.dialectTypes,
+    notNull: asOptions.notNull ?? asDefinition.notNull,
+    primary: asOptions.primary ?? asDefinition.primary,
+    tsType: asDefinition.tsType ?? asOptions.tsType,
+    unique: asDefinition.unique,
+    default: asDefinition.default,
+    autoIncrement: asDefinition.autoIncrement,
+    generated: asDefinition.generated,
+    check: asDefinition.check,
+    references: asDefinition.references,
+    comment: asDefinition.comment,
+    name: asOptions.name ?? asDefinition.name
+  };
+
+  if (!column.type) {
+    throw new Error('Column decorator requires a column type');
+  }
+
+  return column;
+};
+
+const registerColumnFromContext = (
+  targetOrValue: unknown,
+  contextOrProperty: unknown,
+  column: ColumnDefLike
+): void => {
+  const { propertyName, bag } = resolveFieldDecoratorInfo(
+    targetOrValue,
+    contextOrProperty,
+    'Column'
+  );
+  if (!bag.columns.some(entry => entry.propertyName === propertyName)) {
+    bag.columns.push({ propertyName, column: { ...column } });
+  }
+};
+
+/**
+ * Decorator to define a column on an entity property.
+ * @param definition - The column definition or options.
+ * @returns A property decorator that registers the column metadata.
+ */
+export function Column(definition: ColumnInput) {
+  const normalized = normalizeColumnInput(definition);
+  return function (targetOrValue: unknown, contextOrProperty: unknown) {
+    registerColumnFromContext(targetOrValue, contextOrProperty, normalized);
+  };
+}
+
+/**
+ * Decorator to define a primary key column on an entity property.
+ * Sets the primary flag to true and delegates to Column decorator.
+ * @param definition - The column definition or options.
+ * @returns A property decorator that registers the primary key column metadata.
+ */
+export function PrimaryKey(definition: ColumnInput) {
+  const normalized = normalizeColumnInput(definition);
+  normalized.primary = true;
+  return Column(normalized);
+}

package/src/decorators/decorator-metadata.ts

@@ -1,27 +1,32 @@
 import { ColumnDefLike, RelationMetadata } from '../orm/entity-metadata.js';
 import type { TransformerMetadata } from './transformers/transformer-metadata.js';
 
-/**
- * Bag for storing decorator metadata during the decoration phase.
- */
-export interface DecoratorTreeMetadata {
-  parentProperty?: string;
-  childrenProperty?: string;
-}
-
-export interface DecoratorMetadataBag {
-  columns: Array<{ propertyName: string; column: ColumnDefLike }>;
-  relations: Array<{ propertyName: string; relation: RelationMetadata }>;
-  transformers: Array<{ propertyName: string; metadata: TransformerMetadata }>;
-  tree?: DecoratorTreeMetadata;
-}
+/**
+ * Bag for storing decorator metadata during the decoration phase.
+ */
+export interface DecoratorTreeMetadata {
+  parentProperty?: string;
+  childrenProperty?: string;
+}
+
+export interface DecoratorMetadataBag {
+  columns: Array<{ propertyName: string; column: ColumnDefLike }>;
+  relations: Array<{ propertyName: string; relation: RelationMetadata }>;
+  transformers: Array<{ propertyName: string; metadata: TransformerMetadata }>;
+  tree?: DecoratorTreeMetadata;
+}
 
 const METADATA_KEY = 'metal-orm:decorators';
+const LEGACY_METADATA_KEY = Symbol.for('metal-orm:decorators:legacy');
 
 type MetadataCarrier = {
   metadata?: Record<PropertyKey, unknown>;
 };
 
+type LegacyMetadataCarrier = {
+  constructor?: object;
+};
+
 /**
  * Gets or creates a metadata bag for the given decorator context.
  * @param context - The decorator context with metadata support.
@@ -29,13 +34,23 @@ type MetadataCarrier = {
  */
 export const getOrCreateMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag => {
   const metadata = context.metadata || (context.metadata = {} as Record<PropertyKey, unknown>);
-  let bag = metadata[METADATA_KEY] as DecoratorMetadataBag | undefined;
-  if (!bag) {
-    bag = { columns: [], relations: [], transformers: [] };
-    metadata[METADATA_KEY] = bag;
-  }
-  return bag;
-};
+  let bag = metadata[METADATA_KEY] as DecoratorMetadataBag | undefined;
+  if (!bag) {
+    bag = { columns: [], relations: [], transformers: [] };
+    metadata[METADATA_KEY] = bag;
+  }
+  return bag;
+};
+
+const getOrCreateMetadataBagOnConstructor = (ctor: object): DecoratorMetadataBag => {
+  const carrier = ctor as Record<PropertyKey, unknown>;
+  let bag = carrier[LEGACY_METADATA_KEY] as DecoratorMetadataBag | undefined;
+  if (!bag) {
+    bag = { columns: [], relations: [], transformers: [] };
+    carrier[LEGACY_METADATA_KEY] = bag;
+  }
+  return bag;
+};
 
 /**
  * Reads the metadata bag from the given decorator context.
@@ -53,9 +68,14 @@ export const readMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag
  */
 export const readMetadataBagFromConstructor = (ctor: object): DecoratorMetadataBag | undefined => {
   const metadataSymbol = (Symbol as { metadata?: symbol }).metadata;
-  if (!metadataSymbol) return undefined;
-  const metadata = Reflect.get(ctor, metadataSymbol) as Record<PropertyKey, unknown> | undefined;
-  return metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
+  if (metadataSymbol) {
+    const metadata = Reflect.get(ctor, metadataSymbol) as Record<PropertyKey, unknown> | undefined;
+    const stage3Bag = metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
+    if (stage3Bag) {
+      return stage3Bag;
+    }
+  }
+  return (ctor as Record<PropertyKey, unknown>)[LEGACY_METADATA_KEY] as DecoratorMetadataBag | undefined;
 };
 
 /**
@@ -65,3 +85,59 @@ export const readMetadataBagFromConstructor = (ctor: object): DecoratorMetadataB
  */
 export const getDecoratorMetadata = (ctor: object): DecoratorMetadataBag | undefined =>
   readMetadataBagFromConstructor(ctor);
+
+const normalizePropertyName = (name: string | symbol): string => {
+  if (typeof name === 'symbol') {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+
+const isStage3FieldContext = (value: unknown): value is ClassFieldDecoratorContext => {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'name' in value &&
+    'private' in value &&
+    'metadata' in value
+  );
+};
+
+export interface ResolvedFieldDecoratorInfo {
+  bag: DecoratorMetadataBag;
+  propertyName: string;
+}
+
+export const resolveFieldDecoratorInfo = (
+  targetOrValue: unknown,
+  contextOrProperty: unknown,
+  decoratorName: string
+): ResolvedFieldDecoratorInfo => {
+  if (isStage3FieldContext(contextOrProperty)) {
+    if (!contextOrProperty.name) {
+      throw new Error(`${decoratorName} decorator requires a property name`);
+    }
+    if (contextOrProperty.private) {
+      throw new Error(`${decoratorName} decorator does not support private fields`);
+    }
+    return {
+      propertyName: normalizePropertyName(contextOrProperty.name),
+      bag: getOrCreateMetadataBag(contextOrProperty)
+    };
+  }
+
+  if (typeof contextOrProperty === 'string' || typeof contextOrProperty === 'symbol') {
+    const legacyTarget = targetOrValue as LegacyMetadataCarrier | undefined;
+    const ctor =
+      typeof legacyTarget === 'function' ? legacyTarget : legacyTarget?.constructor;
+    if (!ctor || (typeof ctor !== 'function' && typeof ctor !== 'object')) {
+      throw new Error(`${decoratorName} decorator requires a class field target`);
+    }
+    return {
+      propertyName: normalizePropertyName(contextOrProperty),
+      bag: getOrCreateMetadataBagOnConstructor(ctor)
+    };
+  }
+
+  throw new Error(`${decoratorName} decorator received an unsupported decorator context`);
+};

package/src/decorators/entity.ts

@@ -1,14 +1,14 @@
 import { TableHooks } from '../schema/table.js';
 import { RelationKinds } from '../schema/relation.js';
-import {
-  addColumnMetadata,
-  addRelationMetadata,
-  EntityConstructor,
+import {
+  addColumnMetadata,
+  addRelationMetadata,
+  EntityConstructor,
   ensureEntityMetadata,
-  setEntityTableName
-} from '../orm/entity-metadata.js';
-import { readMetadataBag } from './decorator-metadata.js';
-import { syncTreeEntityMetadata } from '../tree/tree-decorator.js';
+  setEntityTableName
+} from '../orm/entity-metadata.js';
+import { readMetadataBag, readMetadataBagFromConstructor } from './decorator-metadata.js';
+import { syncTreeEntityMetadata } from '../tree/tree-decorator.js';
 
 /**
  * Options for defining an entity.
@@ -46,15 +46,18 @@ const deriveTableNameFromConstructor = (ctor: EntityConstructor<unknown>): strin
  * @returns A class decorator that registers the entity metadata.
  */
 export function Entity(options: EntityOptions = {}) {
-  return function <T extends EntityConstructor>(value: T, context: ClassDecoratorContext): T {
+  return function <T extends EntityConstructor>(
+    value: T,
+    context?: ClassDecoratorContext
+  ): T {
     const ctor = value;
     const tableName = options.tableName ?? deriveTableNameFromConstructor(ctor);
     setEntityTableName(ctor, tableName, options.hooks, options.type);
 
-    const bag = readMetadataBag(context);
-    if (bag) {
-      const meta = ensureEntityMetadata(ctor);
-      for (const entry of bag.columns) {
+    const bag = context ? readMetadataBag(context) : readMetadataBagFromConstructor(ctor);
+    if (bag) {
+      const meta = ensureEntityMetadata(ctor);
+      for (const entry of bag.columns) {
         if (meta.columns[entry.propertyName]) {
           throw new Error(
             `Column '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
@@ -77,14 +80,14 @@ export function Entity(options: EntityOptions = {}) {
                 : undefined
             }
             : { ...entry.relation };
-        addRelationMetadata(ctor, entry.propertyName, relationCopy);
-      }
-    }
-
-    // Supports both decorator orders:
-    // @Entity() above @Tree() and @Tree() above @Entity().
-    syncTreeEntityMetadata(ctor, bag?.tree);
-
-    return ctor;
-  };
-}
+        addRelationMetadata(ctor, entry.propertyName, relationCopy);
+      }
+    }
+
+    // Supports both decorator orders:
+    // @Entity() above @Tree() and @Tree() above @Entity().
+    syncTreeEntityMetadata(ctor, bag?.tree);
+
+    return ctor;
+  };
+}