metal-orm 1.0.33 → 1.0.34

package/dist/index.js

@@ -4968,12 +4968,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;
@@ -7471,6 +7501,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) {
@@ -7643,17 +7918,24 @@ function createTediousExecutor(connection, module, options) {
 }
 export {
   AsyncLocalStorage,
+  BelongsTo,
+  BelongsToMany,
+  Column,
   DefaultBelongsToReference,
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
   DeleteQueryBuilder,
   DomainEventBus,
+  Entity,
   EntityStatus,
+  HasMany,
+  HasOne,
   InsertQueryBuilder,
   MySqlDialect,
   Orm,
   OrmSession,
   PostgresDialect,
+  PrimaryKey,
   RelationKinds,
   SelectQueryBuilder,
   SqlServerDialect,
@@ -7672,6 +7954,7 @@ export {
   belongsTo,
   belongsToMany,
   between,
+  bootstrapEntities,
   caseWhen,
   ceil,
   ceiling,
@@ -7726,6 +8009,7 @@ export {
   generateCreateTableSql,
   generateSchemaSql,
   getSchemaIntrospector,
+  getTableDefFromEntity,
   groupConcat,
   gt,
   gte,
@@ -7798,6 +8082,7 @@ export {
   rpad,
   rtrim,
   sel,
+  selectFromEntity,
   sign,
   sin,
   space,