metal-orm 1.1.11 → 1.1.16

package/src/decorators/column-decorator.ts

@@ -1,87 +1,87 @@
-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);
-}
+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,143 +1,143 @@
-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;
-}
-
-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.
- * @returns The metadata bag.
- */
-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;
-};
-
-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.
- * @param context - The decorator context with metadata support.
- * @returns The metadata bag if present.
- */
-export const readMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag | undefined => {
-  return context.metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
-};
-
-/**
- * Reads the metadata bag from a decorated constructor when using standard decorators.
- * @param ctor - The entity constructor.
- * @returns The metadata bag if present.
- */
-export const readMetadataBagFromConstructor = (ctor: object): DecoratorMetadataBag | undefined => {
-  const metadataSymbol = (Symbol as { metadata?: symbol }).metadata;
-  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;
-};
-
-/**
- * Public helper to read decorator metadata from a class constructor.
- * @param ctor - The entity constructor.
- * @returns The metadata bag if present.
- */
-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`);
-};
+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;
+}
+
+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.
+ * @returns The metadata bag.
+ */
+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;
+};
+
+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.
+ * @param context - The decorator context with metadata support.
+ * @returns The metadata bag if present.
+ */
+export const readMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag | undefined => {
+  return context.metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
+};
+
+/**
+ * Reads the metadata bag from a decorated constructor when using standard decorators.
+ * @param ctor - The entity constructor.
+ * @returns The metadata bag if present.
+ */
+export const readMetadataBagFromConstructor = (ctor: object): DecoratorMetadataBag | undefined => {
+  const metadataSymbol = (Symbol as { metadata?: symbol }).metadata;
+  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;
+};
+
+/**
+ * Public helper to read decorator metadata from a class constructor.
+ * @param ctor - The entity constructor.
+ * @returns The metadata bag if present.
+ */
+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,93 +1,93 @@
-import { TableHooks } from '../schema/table.js';
-import { RelationKinds } from '../schema/relation.js';
-import {
-  addColumnMetadata,
-  addRelationMetadata,
-  EntityConstructor,
-  ensureEntityMetadata,
-  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.
- */
-export interface EntityOptions {
-  tableName?: string;
-  hooks?: TableHooks;
-  /** Entity type: 'table' (default) or 'view'. Views are read-only. */
-  type?: 'table' | 'view';
-}
-
-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: EntityConstructor<unknown>): 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`;
-};
-
-/**
- * Class decorator to mark a class as an entity and configure its table mapping.
- * @param options - Configuration options for the entity.
- * @returns A class decorator that registers the entity metadata.
- */
-export function Entity(options: EntityOptions = {}) {
-  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 = 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}'.`
-          );
-        }
-        addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
-      }
-      for (const entry of bag.relations) {
-        if (meta.relations[entry.propertyName]) {
-          throw new Error(
-            `Relation '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
-          );
-        }
-        const relationCopy =
-          entry.relation.kind === RelationKinds.BelongsToMany
-            ? {
-              ...entry.relation,
-              defaultPivotColumns: entry.relation.defaultPivotColumns
-                ? [...entry.relation.defaultPivotColumns]
-                : 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;
-  };
-}
+import { TableHooks } from '../schema/table.js';
+import { RelationKinds } from '../schema/relation.js';
+import {
+  addColumnMetadata,
+  addRelationMetadata,
+  EntityConstructor,
+  ensureEntityMetadata,
+  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.
+ */
+export interface EntityOptions {
+  tableName?: string;
+  hooks?: TableHooks;
+  /** Entity type: 'table' (default) or 'view'. Views are read-only. */
+  type?: 'table' | 'view';
+}
+
+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: EntityConstructor<unknown>): 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`;
+};
+
+/**
+ * Class decorator to mark a class as an entity and configure its table mapping.
+ * @param options - Configuration options for the entity.
+ * @returns A class decorator that registers the entity metadata.
+ */
+export function Entity(options: EntityOptions = {}) {
+  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 = 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}'.`
+          );
+        }
+        addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
+      }
+      for (const entry of bag.relations) {
+        if (meta.relations[entry.propertyName]) {
+          throw new Error(
+            `Relation '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
+          );
+        }
+        const relationCopy =
+          entry.relation.kind === RelationKinds.BelongsToMany
+            ? {
+              ...entry.relation,
+              defaultPivotColumns: entry.relation.defaultPivotColumns
+                ? [...entry.relation.defaultPivotColumns]
+                : 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;
+  };
+}