metal-orm 1.0.24 → 1.0.25

package/README.md

@@ -117,6 +117,8 @@ You don’t have to use decorators, but when you do, you’re still on the same
 <a id="installation"></a>
 ## Installation 📦
 
+**Requirements:** Node.js ≥ 20.0.0. For TypeScript projects, use TS 5.6+ to get the standard decorators API and typings.
+
 ```bash
 # npm
 npm install metal-orm

package/dist/decorators/index.cjs

@@ -109,6 +109,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();
@@ -129,7 +151,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
@@ -176,11 +219,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");
     }
@@ -259,9 +323,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");
     }