metal-orm 1.0.24 → 1.0.27

package/dist/decorators/index.d.cts

@@ -1,10 +1,27 @@
 import { a2 as TableHooks, a4 as ColumnType, h as ColumnDef, aV as EntityOrTableTargetResolver, ab as CascadeMode, i as TableDef, aW as EntityConstructor, Z as SelectQueryBuilder } from '../select-BuMpVcVt.cjs';
 
+interface StandardDecoratorContext {
+    kind: string;
+    name?: string | symbol;
+    metadata?: Record<PropertyKey, unknown>;
+    addInitializer?(initializer: (this: unknown) => void): void;
+    static?: boolean;
+    private?: boolean;
+}
+interface DualModePropertyDecorator {
+    (target: object, propertyKey: string | symbol): void;
+    (value: unknown, context: StandardDecoratorContext): void;
+}
+interface DualModeClassDecorator {
+    <TFunction extends Function>(value: TFunction): void | TFunction;
+    <TFunction extends Function>(value: TFunction, context: StandardDecoratorContext): void | TFunction;
+}
+
 interface EntityOptions {
     tableName?: string;
     hooks?: TableHooks;
 }
-declare function Entity(options?: EntityOptions): ClassDecorator;
+declare function Entity(options?: EntityOptions): DualModeClassDecorator;
 
 interface ColumnOptions {
     type: ColumnType;
@@ -13,8 +30,8 @@ interface ColumnOptions {
     primary?: boolean;
 }
 type ColumnInput = ColumnOptions | ColumnDef;
-declare function Column(definition: ColumnInput): PropertyDecorator;
-declare function PrimaryKey(definition: ColumnInput): PropertyDecorator;
+declare function Column(definition: ColumnInput): DualModePropertyDecorator;
+declare function PrimaryKey(definition: ColumnInput): DualModePropertyDecorator;
 
 interface BaseRelationOptions {
     target: EntityOrTableTargetResolver;
@@ -41,10 +58,10 @@ interface BelongsToManyOptions {
     defaultPivotColumns?: string[];
     cascade?: CascadeMode;
 }
-declare function HasMany(options: HasManyOptions): PropertyDecorator;
-declare function HasOne(options: HasOneOptions): PropertyDecorator;
-declare function BelongsTo(options: BelongsToOptions): PropertyDecorator;
-declare function BelongsToMany(options: BelongsToManyOptions): PropertyDecorator;
+declare function HasMany(options: HasManyOptions): DualModePropertyDecorator;
+declare function HasOne(options: HasOneOptions): DualModePropertyDecorator;
+declare function BelongsTo(options: BelongsToOptions): DualModePropertyDecorator;
+declare function BelongsToMany(options: BelongsToManyOptions): DualModePropertyDecorator;
 
 declare const bootstrapEntities: () => TableDef[];
 declare const getTableDefFromEntity: (ctor: EntityConstructor) => TableDef | undefined;

package/dist/decorators/index.d.ts

@@ -1,10 +1,27 @@
 import { a2 as TableHooks, a4 as ColumnType, h as ColumnDef, aV as EntityOrTableTargetResolver, ab as CascadeMode, i as TableDef, aW as EntityConstructor, Z as SelectQueryBuilder } from '../select-BuMpVcVt.js';
 
+interface StandardDecoratorContext {
+    kind: string;
+    name?: string | symbol;
+    metadata?: Record<PropertyKey, unknown>;
+    addInitializer?(initializer: (this: unknown) => void): void;
+    static?: boolean;
+    private?: boolean;
+}
+interface DualModePropertyDecorator {
+    (target: object, propertyKey: string | symbol): void;
+    (value: unknown, context: StandardDecoratorContext): void;
+}
+interface DualModeClassDecorator {
+    <TFunction extends Function>(value: TFunction): void | TFunction;
+    <TFunction extends Function>(value: TFunction, context: StandardDecoratorContext): void | TFunction;
+}
+
 interface EntityOptions {
     tableName?: string;
     hooks?: TableHooks;
 }
-declare function Entity(options?: EntityOptions): ClassDecorator;
+declare function Entity(options?: EntityOptions): DualModeClassDecorator;
 
 interface ColumnOptions {
     type: ColumnType;
@@ -13,8 +30,8 @@ interface ColumnOptions {
     primary?: boolean;
 }
 type ColumnInput = ColumnOptions | ColumnDef;
-declare function Column(definition: ColumnInput): PropertyDecorator;
-declare function PrimaryKey(definition: ColumnInput): PropertyDecorator;
+declare function Column(definition: ColumnInput): DualModePropertyDecorator;
+declare function PrimaryKey(definition: ColumnInput): DualModePropertyDecorator;
 
 interface BaseRelationOptions {
     target: EntityOrTableTargetResolver;
@@ -41,10 +58,10 @@ interface BelongsToManyOptions {
     defaultPivotColumns?: string[];
     cascade?: CascadeMode;
 }
-declare function HasMany(options: HasManyOptions): PropertyDecorator;
-declare function HasOne(options: HasOneOptions): PropertyDecorator;
-declare function BelongsTo(options: BelongsToOptions): PropertyDecorator;
-declare function BelongsToMany(options: BelongsToManyOptions): PropertyDecorator;
+declare function HasMany(options: HasManyOptions): DualModePropertyDecorator;
+declare function HasOne(options: HasOneOptions): DualModePropertyDecorator;
+declare function BelongsTo(options: BelongsToOptions): DualModePropertyDecorator;
+declare function BelongsToMany(options: BelongsToManyOptions): DualModePropertyDecorator;
 
 declare const bootstrapEntities: () => TableDef[];
 declare const getTableDefFromEntity: (ctor: EntityConstructor) => TableDef | undefined;

package/dist/decorators/index.js

@@ -75,6 +75,28 @@ var buildTableDef = (meta) => {
   return table;
 };
 
+// src/decorators/decorator-metadata.ts
+var METADATA_KEY = "metal-orm:decorators";
+var isStandardDecoratorContext = (value) => {
+  return typeof value === "object" && value !== null && "kind" in value;
+};
+var getOrCreateMetadataBag = (context) => {
+  const metadata = context.metadata || (context.metadata = {});
+  const existing = metadata[METADATA_KEY];
+  if (existing) {
+    return existing;
+  }
+  const bag = { columns: [], relations: [] };
+  metadata[METADATA_KEY] = bag;
+  return bag;
+};
+var readMetadataBag = (context) => {
+  return context.metadata?.[METADATA_KEY];
+};
+var registerInitializer = (context, initializer) => {
+  context.addInitializer?.(initializer);
+};
+
 // src/decorators/entity.ts
 var toSnakeCase = (value) => {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_]+/gi, "_").replace(/__+/g, "_").replace(/^_|_$/g, "").toLowerCase();
@@ -95,7 +117,28 @@ function Entity(options = {}) {
     setEntityTableName(value, tableName, options.hooks);
     return value;
   };
-  return decorator;
+  const decoratorWithContext = (value, context) => {
+    const ctor = value;
+    decorator(ctor);
+    if (context && isStandardDecoratorContext(context)) {
+      const bag = readMetadataBag(context);
+      if (bag) {
+        const meta = ensureEntityMetadata(ctor);
+        for (const entry of bag.columns) {
+          if (!meta.columns[entry.propertyName]) {
+            addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
+          }
+        }
+        for (const entry of bag.relations) {
+          if (!meta.relations[entry.propertyName]) {
+            addRelationMetadata(ctor, entry.propertyName, entry.relation);
+          }
+        }
+      }
+    }
+    return ctor;
+  };
+  return decoratorWithContext;
 }
 
 // src/decorators/column.ts
@@ -142,11 +185,32 @@ var registerColumn = (ctor, propertyName, column) => {
   }
   addColumnMetadata(ctor, propertyName, column);
 };
+var registerColumnFromContext = (context, column) => {
+  if (!context.name) {
+    throw new Error("Column decorator requires a property name");
+  }
+  const propertyName = normalizePropertyName(context.name);
+  const bag = getOrCreateMetadataBag(context);
+  if (!bag.columns.some((entry) => entry.propertyName === propertyName)) {
+    bag.columns.push({ propertyName, column: { ...column } });
+  }
+  registerInitializer(context, function() {
+    const ctor = resolveConstructor(this);
+    if (!ctor) {
+      return;
+    }
+    registerColumn(ctor, propertyName, column);
+  });
+};
 function Column(definition) {
   const normalized = normalizeColumnInput(definition);
-  const decorator = (target, propertyKey) => {
-    const propertyName = normalizePropertyName(propertyKey);
-    const ctor = resolveConstructor(target);
+  const decorator = (targetOrValue, propertyKeyOrContext) => {
+    if (isStandardDecoratorContext(propertyKeyOrContext)) {
+      registerColumnFromContext(propertyKeyOrContext, normalized);
+      return;
+    }
+    const propertyName = normalizePropertyName(propertyKeyOrContext);
+    const ctor = resolveConstructor(targetOrValue);
     if (!ctor) {
       throw new Error("Unable to resolve constructor when registering column metadata");
     }
@@ -225,9 +289,29 @@ var registerRelation = (ctor, propertyName, metadata) => {
   addRelationMetadata(ctor, propertyName, metadata);
 };
 var createFieldDecorator = (metadataFactory) => {
-  const decorator = (target, propertyKey) => {
-    const propertyName = normalizePropertyName2(propertyKey);
-    const ctor = resolveConstructor2(target);
+  const decorator = (targetOrValue, propertyKeyOrContext) => {
+    if (isStandardDecoratorContext(propertyKeyOrContext)) {
+      const ctx = propertyKeyOrContext;
+      if (!ctx.name) {
+        throw new Error("Relation decorator requires a property name");
+      }
+      const propertyName2 = normalizePropertyName2(ctx.name);
+      const bag = getOrCreateMetadataBag(ctx);
+      const relationMetadata = metadataFactory(propertyName2);
+      if (!bag.relations.some((entry) => entry.propertyName === propertyName2)) {
+        bag.relations.push({ propertyName: propertyName2, relation: relationMetadata });
+      }
+      registerInitializer(ctx, function() {
+        const ctor2 = resolveConstructor2(this);
+        if (!ctor2) {
+          return;
+        }
+        registerRelation(ctor2, propertyName2, relationMetadata);
+      });
+      return;
+    }
+    const propertyName = normalizePropertyName2(propertyKeyOrContext);
+    const ctor = resolveConstructor2(targetOrValue);
     if (!ctor) {
       throw new Error("Unable to resolve constructor when registering relation metadata");
     }