metal-orm 1.0.32 → 1.0.34

package/README.md

@@ -335,7 +335,7 @@ const [user] = await new SelectQueryBuilder(users)
   .where(eq(users.columns.id, 1))
   .execute(session);
 
-// user is an Entity<typeof users>
+// user is an EntityInstance<typeof users>
 // scalar props are normal:
 user.name = 'Updated Name';  // marks entity as Dirty
 
@@ -365,12 +365,14 @@ What the runtime gives you:
 
 Finally, you can describe your models with decorators and still use the same runtime and query builder.
 
-> Import paths here assume a `metal-orm/decorators` subpath export – adjust if your bundle exposes them differently.
-
 ```ts
 import mysql from 'mysql2/promise';
-import { Orm, OrmSession, MySqlDialect, col, createMysqlExecutor } from 'metal-orm';
 import {
+  Orm,
+  OrmSession,
+  MySqlDialect,
+  col,
+  createMysqlExecutor,
   Entity,
   Column,
   PrimaryKey,
@@ -378,7 +380,7 @@ import {
   BelongsTo,
   bootstrapEntities,
   selectFromEntity,
-} from 'metal-orm/decorators';
+} from 'metal-orm';
 
 @Entity()
 class User {

package/dist/index.cjs

@@ -44,17 +44,24 @@ var init_schema_plan_executor = __esm({
 var index_exports = {};
 __export(index_exports, {
   AsyncLocalStorage: () => AsyncLocalStorage,
+  BelongsTo: () => BelongsTo,
+  BelongsToMany: () => BelongsToMany,
+  Column: () => Column,
   DefaultBelongsToReference: () => DefaultBelongsToReference,
   DefaultHasManyCollection: () => DefaultHasManyCollection,
   DefaultManyToManyCollection: () => DefaultManyToManyCollection,
   DeleteQueryBuilder: () => DeleteQueryBuilder,
   DomainEventBus: () => DomainEventBus,
+  Entity: () => Entity,
   EntityStatus: () => EntityStatus,
+  HasMany: () => HasMany,
+  HasOne: () => HasOne,
   InsertQueryBuilder: () => InsertQueryBuilder,
   MySqlDialect: () => MySqlDialect,
   Orm: () => Orm,
   OrmSession: () => OrmSession,
   PostgresDialect: () => PostgresDialect,
+  PrimaryKey: () => PrimaryKey,
   RelationKinds: () => RelationKinds,
   SelectQueryBuilder: () => SelectQueryBuilder,
   SqlServerDialect: () => SqlServerDialect,
@@ -73,6 +80,7 @@ __export(index_exports, {
   belongsTo: () => belongsTo,
   belongsToMany: () => belongsToMany,
   between: () => between,
+  bootstrapEntities: () => bootstrapEntities,
   caseWhen: () => caseWhen,
   ceil: () => ceil,
   ceiling: () => ceiling,
@@ -127,6 +135,7 @@ __export(index_exports, {
   generateCreateTableSql: () => generateCreateTableSql,
   generateSchemaSql: () => generateSchemaSql,
   getSchemaIntrospector: () => getSchemaIntrospector,
+  getTableDefFromEntity: () => getTableDefFromEntity,
   groupConcat: () => groupConcat,
   gt: () => gt,
   gte: () => gte,
@@ -199,6 +208,7 @@ __export(index_exports, {
   rpad: () => rpad,
   rtrim: () => rtrim,
   sel: () => sel,
+  selectFromEntity: () => selectFromEntity,
   sign: () => sign,
   sin: () => sin,
   space: () => space,
@@ -5163,12 +5173,42 @@ var createLiteral = (val) => ({ type: "Literal", value: val });
 
 // src/orm/entity-metadata.ts
 var metadataMap = /* @__PURE__ */ new Map();
+var ensureEntityMetadata = (target) => {
+  let meta = metadataMap.get(target);
+  if (!meta) {
+    meta = {
+      target,
+      tableName: target.name || "unknown",
+      columns: {},
+      relations: {}
+    };
+    metadataMap.set(target, meta);
+  }
+  return meta;
+};
 var getEntityMetadata = (target) => {
   return metadataMap.get(target);
 };
 var getAllEntityMetadata = () => {
   return Array.from(metadataMap.values());
 };
+var addColumnMetadata = (target, propertyKey, column) => {
+  const meta = ensureEntityMetadata(target);
+  meta.columns[propertyKey] = { ...column };
+};
+var addRelationMetadata = (target, propertyKey, relation) => {
+  const meta = ensureEntityMetadata(target);
+  meta.relations[propertyKey] = relation;
+};
+var setEntityTableName = (target, tableName, hooks) => {
+  const meta = ensureEntityMetadata(target);
+  if (tableName && tableName.length > 0) {
+    meta.tableName = tableName;
+  }
+  if (hooks) {
+    meta.hooks = hooks;
+  }
+};
 var buildTableDef = (meta) => {
   if (meta.table) {
     return meta.table;
@@ -7666,6 +7706,251 @@ var Orm = class {
   }
 };
 
+// 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();
+};
+var deriveTableNameFromConstructor = (ctor) => {
+  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`;
+};
+function Entity(options = {}) {
+  const decorator = (value) => {
+    const tableName = options.tableName ?? deriveTableNameFromConstructor(value);
+    setEntityTableName(value, tableName, options.hooks);
+    return value;
+  };
+  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
+var normalizeColumnInput = (input) => {
+  const asOptions = input;
+  const asDefinition = input;
+  const column = {
+    type: asOptions.type ?? asDefinition.type,
+    args: asOptions.args ?? asDefinition.args,
+    notNull: asOptions.notNull ?? asDefinition.notNull,
+    primary: asOptions.primary ?? asDefinition.primary,
+    unique: asDefinition.unique,
+    default: asDefinition.default,
+    autoIncrement: asDefinition.autoIncrement,
+    generated: asDefinition.generated,
+    check: asDefinition.check,
+    references: asDefinition.references,
+    comment: asDefinition.comment
+  };
+  if (!column.type) {
+    throw new Error("Column decorator requires a column type");
+  }
+  return column;
+};
+var normalizePropertyName = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+var resolveConstructor = (target) => {
+  if (typeof target === "function") {
+    return target;
+  }
+  if (target && typeof target.constructor === "function") {
+    return target.constructor;
+  }
+  return void 0;
+};
+var registerColumn = (ctor, propertyName, column) => {
+  const meta = ensureEntityMetadata(ctor);
+  if (meta.columns[propertyName]) {
+    return;
+  }
+  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 = (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;
+}
+function PrimaryKey(definition) {
+  const normalized = normalizeColumnInput(definition);
+  normalized.primary = true;
+  return Column(normalized);
+}
+
+// src/decorators/relations.ts
+var normalizePropertyName2 = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+var resolveConstructor2 = (instanceOrCtor) => {
+  if (typeof instanceOrCtor === "function") {
+    return instanceOrCtor;
+  }
+  if (instanceOrCtor && typeof instanceOrCtor.constructor === "function") {
+    return instanceOrCtor.constructor;
+  }
+  return void 0;
+};
+var registerRelation = (ctor, propertyName, metadata) => {
+  addRelationMetadata(ctor, propertyName, metadata);
+};
+var createFieldDecorator = (metadataFactory) => {
+  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");
+    }
+    registerRelation(ctor, propertyName, metadataFactory(propertyName));
+  };
+  return decorator;
+};
+function HasMany(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.HasMany,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+function HasOne(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.HasOne,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+function BelongsTo(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.BelongsTo,
+    propertyKey: propertyName,
+    target: options.target,
+    foreignKey: options.foreignKey,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+function BelongsToMany(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.BelongsToMany,
+    propertyKey: propertyName,
+    target: options.target,
+    pivotTable: options.pivotTable,
+    pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
+    pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
+    localKey: options.localKey,
+    targetKey: options.targetKey,
+    pivotPrimaryKey: options.pivotPrimaryKey,
+    defaultPivotColumns: options.defaultPivotColumns,
+    cascade: options.cascade
+  }));
+}
+
 // src/core/execution/db-executor.ts
 function rowsToQueryResult(rows) {
   if (rows.length === 0) {
@@ -7839,17 +8124,24 @@ function createTediousExecutor(connection, module2, options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AsyncLocalStorage,
+  BelongsTo,
+  BelongsToMany,
+  Column,
   DefaultBelongsToReference,
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
   DeleteQueryBuilder,
   DomainEventBus,
+  Entity,
   EntityStatus,
+  HasMany,
+  HasOne,
   InsertQueryBuilder,
   MySqlDialect,
   Orm,
   OrmSession,
   PostgresDialect,
+  PrimaryKey,
   RelationKinds,
   SelectQueryBuilder,
   SqlServerDialect,
@@ -7868,6 +8160,7 @@ function createTediousExecutor(connection, module2, options) {
   belongsTo,
   belongsToMany,
   between,
+  bootstrapEntities,
   caseWhen,
   ceil,
   ceiling,
@@ -7922,6 +8215,7 @@ function createTediousExecutor(connection, module2, options) {
   generateCreateTableSql,
   generateSchemaSql,
   getSchemaIntrospector,
+  getTableDefFromEntity,
   groupConcat,
   gt,
   gte,
@@ -7994,6 +8288,7 @@ function createTediousExecutor(connection, module2, options) {
   rpad,
   rtrim,
   sel,
+  selectFromEntity,
   sign,
   sin,
   space,