metal-orm 1.0.23 → 1.0.25

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "metal-orm",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "type": "module",
   "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "bin": {
     "metal-orm-gen": "./scripts/generate-entities.mjs"
   },

package/scripts/generate-entities.mjs

@@ -168,9 +168,12 @@ const parseColumnType = colTypeRaw => {
 
   const base = type.replace(/\(.*\)/, '');
 
+  if (base === 'bit') return { factory: 'col.boolean()', ts: 'boolean' };
   if (base.includes('bigint')) return { factory: 'col.bigint()', ts: 'number' };
   if (base.includes('int')) return { factory: 'col.int()', ts: 'number' };
-  if (base.includes('uuid')) return { factory: 'col.uuid()', ts: 'string' };
+  if (base.includes('uuid') || base.includes('uniqueidentifier')) return { factory: 'col.uuid()', ts: 'string' };
+  if (base === 'date') return { factory: 'col.date()', ts: 'Date' };
+  if (base.includes('datetime') || base === 'time') return { factory: 'col.datetime()', ts: 'Date' };
   if (base.includes('char') || base.includes('text')) {
     const lenArg = length ? `${length}` : '255';
     return { factory: `col.varchar(${lenArg})`, ts: 'string' };
@@ -368,16 +371,86 @@ const renderEntityFile = (schema, options) => {
 
   const relations = mapRelations(tables);
 
-  const imports = [
-    "import { col } from 'metal-orm';",
-    "import { Entity, Column, PrimaryKey, HasMany, BelongsTo, BelongsToMany, bootstrapEntities, getTableDefFromEntity } from 'metal-orm/decorators';",
-    "import { HasManyCollection, ManyToManyCollection } from 'metal-orm';"
-  ];
+  const usage = {
+    needsCol: false,
+    needsEntity: tables.length > 0,
+    needsColumnDecorator: false,
+    needsPrimaryKeyDecorator: false,
+    needsHasManyDecorator: false,
+    needsBelongsToDecorator: false,
+    needsBelongsToManyDecorator: false,
+    needsHasManyCollection: false,
+    needsManyToManyCollection: false
+  };
 
   const lines = [];
   lines.push('// AUTO-GENERATED by scripts/generate-entities.mjs');
   lines.push('// Regenerate after schema changes.');
-  lines.push(...imports, '');
+  const imports = [];
+
+  for (const table of tables) {
+    for (const col of table.columns) {
+      usage.needsCol = true;
+      const rendered = renderColumnExpression(col, table.primaryKey);
+      if (rendered.decorator === 'PrimaryKey') {
+        usage.needsPrimaryKeyDecorator = true;
+      } else {
+        usage.needsColumnDecorator = true;
+      }
+    }
+
+    const rels = relations.get(table.name) || [];
+    for (const rel of rels) {
+      if (rel.kind === 'hasMany') {
+        usage.needsHasManyDecorator = true;
+        usage.needsHasManyCollection = true;
+      }
+      if (rel.kind === 'belongsTo') {
+        usage.needsBelongsToDecorator = true;
+      }
+      if (rel.kind === 'belongsToMany') {
+        usage.needsBelongsToManyDecorator = true;
+        usage.needsManyToManyCollection = true;
+      }
+    }
+  }
+
+  if (usage.needsCol) {
+    imports.push("import { col } from 'metal-orm';");
+  }
+
+  const decoratorSet = new Set(['bootstrapEntities', 'getTableDefFromEntity']);
+  if (usage.needsEntity) decoratorSet.add('Entity');
+  if (usage.needsColumnDecorator) decoratorSet.add('Column');
+  if (usage.needsPrimaryKeyDecorator) decoratorSet.add('PrimaryKey');
+  if (usage.needsHasManyDecorator) decoratorSet.add('HasMany');
+  if (usage.needsBelongsToDecorator) decoratorSet.add('BelongsTo');
+  if (usage.needsBelongsToManyDecorator) decoratorSet.add('BelongsToMany');
+  const decoratorOrder = [
+    'Entity',
+    'Column',
+    'PrimaryKey',
+    'HasMany',
+    'BelongsTo',
+    'BelongsToMany',
+    'bootstrapEntities',
+    'getTableDefFromEntity'
+  ];
+  const decoratorImports = decoratorOrder.filter(name => decoratorSet.has(name));
+  if (decoratorImports.length) {
+    imports.push(`import { ${decoratorImports.join(', ')} } from 'metal-orm/decorators';`);
+  }
+
+  const ormTypes = [];
+  if (usage.needsHasManyCollection) ormTypes.push('HasManyCollection');
+  if (usage.needsManyToManyCollection) ormTypes.push('ManyToManyCollection');
+  if (ormTypes.length) {
+    imports.push(`import { ${ormTypes.join(', ')} } from 'metal-orm';`);
+  }
+
+  if (imports.length) {
+    lines.push(...imports, '');
+  }
 
   for (const table of tables) {
     const className = classNames.get(table.name);

package/src/decorators/column.ts

@@ -5,6 +5,13 @@ import {
   ColumnDefLike,
   ensureEntityMetadata
 } from '../orm/entity-metadata.js';
+import {
+  DualModePropertyDecorator,
+  getOrCreateMetadataBag,
+  isStandardDecoratorContext,
+  registerInitializer,
+  StandardDecoratorContext
+} from './decorator-metadata.js';
 
 export interface ColumnOptions {
   type: ColumnType;
@@ -66,18 +73,45 @@ const registerColumn = (ctor: EntityConstructor, propertyName: string, column: C
   addColumnMetadata(ctor, propertyName, column);
 };
 
+const registerColumnFromContext = (
+  context: StandardDecoratorContext,
+  column: ColumnDefLike
+): void => {
+  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);
+  });
+};
+
 export function Column(definition: ColumnInput) {
   const normalized = normalizeColumnInput(definition);
-  const decorator = (target: object, propertyKey: string | symbol) => {
-    const propertyName = normalizePropertyName(propertyKey);
-    const ctor = resolveConstructor(target);
+  const decorator: DualModePropertyDecorator = (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');
     }
     registerColumn(ctor, propertyName, { ...normalized });
   };
 
-  return decorator as PropertyDecorator;
+  return decorator;
 }
 
 export function PrimaryKey(definition: ColumnInput) {

package/src/decorators/decorator-metadata.ts

@@ -0,0 +1,53 @@
+import { ColumnDefLike, RelationMetadata } from '../orm/entity-metadata.js';
+
+export interface StandardDecoratorContext {
+  kind: string;
+  name?: string | symbol;
+  metadata?: Record<PropertyKey, unknown>;
+  addInitializer?(initializer: (this: unknown) => void): void;
+  static?: boolean;
+  private?: boolean;
+}
+
+export interface DualModePropertyDecorator {
+  (target: object, propertyKey: string | symbol): void;
+  (value: unknown, context: StandardDecoratorContext): void;
+}
+
+export interface DualModeClassDecorator {
+  <TFunction extends Function>(value: TFunction): void | TFunction;
+  <TFunction extends Function>(value: TFunction, context: StandardDecoratorContext): void | TFunction;
+}
+
+export interface DecoratorMetadataBag {
+  columns: Array<{ propertyName: string; column: ColumnDefLike }>;
+  relations: Array<{ propertyName: string; relation: RelationMetadata }>;
+}
+
+const METADATA_KEY = 'metal-orm:decorators';
+
+export const isStandardDecoratorContext = (value: unknown): value is StandardDecoratorContext => {
+  return typeof value === 'object' && value !== null && 'kind' in (value as any);
+};
+
+export const getOrCreateMetadataBag = (context: StandardDecoratorContext): DecoratorMetadataBag => {
+  const metadata = context.metadata || (context.metadata = {} as Record<PropertyKey, unknown>);
+  const existing = metadata[METADATA_KEY] as DecoratorMetadataBag | undefined;
+  if (existing) {
+    return existing;
+  }
+  const bag: DecoratorMetadataBag = { columns: [], relations: [] };
+  metadata[METADATA_KEY] = bag;
+  return bag;
+};
+
+export const readMetadataBag = (context: StandardDecoratorContext): DecoratorMetadataBag | undefined => {
+  return context.metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
+};
+
+export const registerInitializer = (
+  context: StandardDecoratorContext,
+  initializer: (this: unknown) => void
+): void => {
+  context.addInitializer?.(initializer);
+};

package/src/decorators/entity.ts

@@ -1,5 +1,12 @@
 import { TableHooks } from '../schema/table.js';
-import { setEntityTableName } from '../orm/entity-metadata.js';
+import {
+  addColumnMetadata,
+  addRelationMetadata,
+  EntityConstructor,
+  ensureEntityMetadata,
+  setEntityTableName
+} from '../orm/entity-metadata.js';
+import { DualModeClassDecorator, isStandardDecoratorContext, readMetadataBag } from './decorator-metadata.js';
 
 export interface EntityOptions {
   tableName?: string;
@@ -27,10 +34,36 @@ const deriveTableNameFromConstructor = (ctor: Function): string => {
 };
 
 export function Entity(options: EntityOptions = {}) {
-  const decorator = <T extends new (...args: any[]) => any>(value: T) => {
+  const decorator: DualModeClassDecorator = value => {
     const tableName = options.tableName ?? deriveTableNameFromConstructor(value);
-    setEntityTableName(value, tableName, options.hooks);
+    setEntityTableName(value as EntityConstructor, tableName, options.hooks);
+
     return value;
   };
-  return decorator as unknown as ClassDecorator;
+
+  const decoratorWithContext: DualModeClassDecorator = (value, context?) => {
+    const ctor = value as EntityConstructor;
+    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;
 }

package/src/decorators/relations.ts

@@ -5,6 +5,13 @@ import {
   EntityOrTableTargetResolver,
   RelationMetadata
 } from '../orm/entity-metadata.js';
+import {
+  DualModePropertyDecorator,
+  getOrCreateMetadataBag,
+  isStandardDecoratorContext,
+  registerInitializer,
+  StandardDecoratorContext
+} from './decorator-metadata.js';
 
 interface BaseRelationOptions {
   target: EntityOrTableTargetResolver;
@@ -60,16 +67,39 @@ const registerRelation = (ctor: EntityConstructor, propertyName: string, metadat
 const createFieldDecorator = (
   metadataFactory: (propertyName: string) => RelationMetadata
 ) => {
-  const decorator = (target: object, propertyKey: string | symbol) => {
-    const propertyName = normalizePropertyName(propertyKey);
-    const ctor = resolveConstructor(target);
+  const decorator: DualModePropertyDecorator = (targetOrValue, propertyKeyOrContext) => {
+    if (isStandardDecoratorContext(propertyKeyOrContext)) {
+      const ctx = propertyKeyOrContext as StandardDecoratorContext;
+      if (!ctx.name) {
+        throw new Error('Relation decorator requires a property name');
+      }
+      const propertyName = normalizePropertyName(ctx.name);
+      const bag = getOrCreateMetadataBag(ctx);
+      const relationMetadata = metadataFactory(propertyName);
+
+      if (!bag.relations.some(entry => entry.propertyName === propertyName)) {
+        bag.relations.push({ propertyName, relation: relationMetadata });
+      }
+
+      registerInitializer(ctx, function () {
+        const ctor = resolveConstructor(this);
+        if (!ctor) {
+          return;
+        }
+        registerRelation(ctor, propertyName, relationMetadata);
+      });
+      return;
+    }
+
+    const propertyName = normalizePropertyName(propertyKeyOrContext);
+    const ctor = resolveConstructor(targetOrValue);
     if (!ctor) {
       throw new Error('Unable to resolve constructor when registering relation metadata');
     }
     registerRelation(ctor, propertyName, metadataFactory(propertyName));
   };
 
-  return decorator as PropertyDecorator;
+  return decorator;
 };
 
 export function HasMany(options: HasManyOptions) {