@famgia/omnify-laravel 0.0.13 → 0.0.14

package/dist/plugin.cjs

@@ -293,11 +293,18 @@ function schemaToBlueprint(schema, allSchemas) {
   }
   if (schema.options?.indexes) {
     for (const index of schema.options.indexes) {
-      indexes.push({
-        name: index.name,
-        columns: index.columns.map(toColumnName),
-        unique: index.unique ?? false
-      });
+      if (typeof index === "string") {
+        indexes.push({
+          columns: [toColumnName(index)],
+          unique: false
+        });
+      } else {
+        indexes.push({
+          name: index.name,
+          columns: index.columns.map(toColumnName),
+          unique: index.unique ?? false
+        });
+      }
     }
   }
   if (schema.options?.unique) {
@@ -684,6 +691,579 @@ function getMigrationPath(migration, outputDir = "database/migrations") {
   return `${outputDir}/${migration.fileName}`;
 }
 
+// src/utils.ts
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
+}
+function toPascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function pluralize(word) {
+  if (word.endsWith("y") && !["ay", "ey", "iy", "oy", "uy"].some((v) => word.endsWith(v))) {
+    return word.slice(0, -1) + "ies";
+  }
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
+  }
+  return word + "s";
+}
+
+// src/model/generator.ts
+var DEFAULT_OPTIONS = {
+  baseModelNamespace: "App\\Models\\OmnifyBase",
+  modelNamespace: "App\\Models",
+  baseModelClassName: "BaseModel",
+  baseModelPath: "app/Models/OmnifyBase",
+  modelPath: "app/Models"
+};
+function resolveOptions(options) {
+  return {
+    baseModelNamespace: options?.baseModelNamespace ?? DEFAULT_OPTIONS.baseModelNamespace,
+    modelNamespace: options?.modelNamespace ?? DEFAULT_OPTIONS.modelNamespace,
+    baseModelClassName: options?.baseModelClassName ?? DEFAULT_OPTIONS.baseModelClassName,
+    baseModelPath: options?.baseModelPath ?? DEFAULT_OPTIONS.baseModelPath,
+    modelPath: options?.modelPath ?? DEFAULT_OPTIONS.modelPath
+  };
+}
+function getCastType(propDef) {
+  switch (propDef.type) {
+    case "Boolean":
+      return "boolean";
+    case "Int":
+    case "BigInt":
+      return "integer";
+    case "Float":
+      return "float";
+    case "Decimal":
+      return "decimal:" + (propDef.scale ?? 2);
+    case "Json":
+      return "array";
+    case "Date":
+      return "date";
+    case "Timestamp":
+      return "datetime";
+    case "Password":
+      return "hashed";
+    default:
+      return null;
+  }
+}
+function isNullable(propDef) {
+  return "nullable" in propDef && propDef.nullable === true;
+}
+function getPhpDocType(propDef, schemas) {
+  const nullable = isNullable(propDef);
+  switch (propDef.type) {
+    case "String":
+    case "Text":
+    case "LongText":
+    case "Email":
+    case "Password":
+      return "string" + (nullable ? "|null" : "");
+    case "Int":
+    case "BigInt":
+      return "int" + (nullable ? "|null" : "");
+    case "Float":
+    case "Decimal":
+      return "float" + (nullable ? "|null" : "");
+    case "Boolean":
+      return "bool" + (nullable ? "|null" : "");
+    case "Date":
+    case "Time":
+    case "Timestamp":
+      return "\\Carbon\\Carbon" + (nullable ? "|null" : "");
+    case "Json":
+      return "array" + (nullable ? "|null" : "");
+    case "Enum":
+    case "EnumRef":
+      return "string" + (nullable ? "|null" : "");
+    case "Association": {
+      const assoc = propDef;
+      if (assoc.target) {
+        const className = toPascalCase(assoc.target);
+        switch (assoc.relation) {
+          case "OneToMany":
+          case "ManyToMany":
+          case "MorphMany":
+          case "MorphToMany":
+          case "MorphedByMany":
+            return `\\Illuminate\\Database\\Eloquent\\Collection<${className}>`;
+          default:
+            return className + "|null";
+        }
+      }
+      return "mixed";
+    }
+    default:
+      return "mixed";
+  }
+}
+function generateBaseModel(schemas, options, stubContent) {
+  const modelMap = Object.values(schemas).filter((s) => s.kind !== "enum").map((s) => {
+    const className = toPascalCase(s.name);
+    return `        '${s.name}' => \\${options.modelNamespace}\\${className}::class,`;
+  }).join("\n");
+  const content = stubContent.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{BASE_MODEL_CLASS\}\}/g, options.baseModelClassName).replace(/\{\{MODEL_MAP\}\}/g, modelMap);
+  return {
+    path: `${options.baseModelPath}/${options.baseModelClassName}.php`,
+    content,
+    type: "base-model",
+    overwrite: true,
+    schemaName: "__base__"
+  };
+}
+function generateEntityBaseModel(schema, schemas, options, stubContent, authStubContent) {
+  const className = toPascalCase(schema.name);
+  const tableName = schema.options?.tableName ?? pluralize(toSnakeCase(schema.name));
+  const isAuth = schema.options?.authenticatable ?? false;
+  const primaryKey = "id";
+  const idType = schema.options?.idType ?? "BigInt";
+  const isUuid = idType === "Uuid";
+  const isStringKey = idType === "Uuid" || idType === "String";
+  const imports = [];
+  const traits = [];
+  const fillable = [];
+  const hidden = [];
+  const appends = [];
+  const casts = [];
+  const relations = [];
+  const docProperties = [];
+  if (schema.options?.softDelete) {
+    imports.push("use Illuminate\\Database\\Eloquent\\SoftDeletes;");
+    traits.push("    use SoftDeletes;");
+  }
+  const properties = schema.properties ?? {};
+  for (const [propName, propDef] of Object.entries(properties)) {
+    const snakeName = toSnakeCase(propName);
+    const phpType = getPhpDocType(propDef, schemas);
+    docProperties.push(` * @property ${phpType} $${snakeName}`);
+    if (propDef.type === "Association") {
+      const assoc = propDef;
+      if (assoc.target) {
+        imports.push(`use ${options.modelNamespace}\\${toPascalCase(assoc.target)};`);
+      }
+      relations.push(generateRelation(propName, assoc, options));
+      if (assoc.relation === "ManyToOne" || assoc.relation === "OneToOne") {
+        if (!assoc.mappedBy) {
+          const fkName = toSnakeCase(propName) + "_id";
+          fillable.push(`        '${fkName}',`);
+          docProperties.push(` * @property int|null $${fkName}`);
+        }
+      }
+    } else if (propDef.type === "Password") {
+      fillable.push(`        '${snakeName}',`);
+      hidden.push(`        '${snakeName}',`);
+      const cast = getCastType(propDef);
+      if (cast) {
+        casts.push(`            '${snakeName}' => '${cast}',`);
+      }
+    } else if (propDef.type === "File") {
+      const relMethod = generateFileRelation(propName, propDef);
+      relations.push(relMethod);
+    } else {
+      fillable.push(`        '${snakeName}',`);
+      const cast = getCastType(propDef);
+      if (cast) {
+        casts.push(`            '${snakeName}' => '${cast}',`);
+      }
+    }
+  }
+  const docComment = `/**
+ * ${className}BaseModel
+ *
+${docProperties.join("\n")}
+ */`;
+  const stub = isAuth ? authStubContent : stubContent;
+  const keyType = isStringKey ? `    /**
+     * The "type" of the primary key ID.
+     */
+    protected $keyType = 'string';
+
+` : "";
+  const incrementing = isUuid ? `    /**
+     * Indicates if the IDs are auto-incrementing.
+     */
+    public $incrementing = false;
+
+` : "";
+  if (isUuid) {
+    imports.push("use Illuminate\\Database\\Eloquent\\Concerns\\HasUuids;");
+    traits.push("    use HasUuids;");
+  }
+  const content = stub.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{BASE_MODEL_CLASS\}\}/g, options.baseModelClassName).replace(/\{\{CLASS_NAME\}\}/g, className).replace(/\{\{TABLE_NAME\}\}/g, tableName).replace(/\{\{PRIMARY_KEY\}\}/g, primaryKey).replace(/\{\{KEY_TYPE\}\}/g, keyType).replace(/\{\{INCREMENTING\}\}/g, incrementing).replace(/\{\{TIMESTAMPS\}\}/g, schema.options?.timestamps !== false ? "true" : "false").replace(/\{\{IMPORTS\}\}/g, [...new Set(imports)].sort().join("\n")).replace(/\{\{TRAITS\}\}/g, traits.join("\n")).replace(/\{\{DOC_COMMENT\}\}/g, docComment).replace(/\{\{FILLABLE\}\}/g, fillable.join("\n")).replace(/\{\{HIDDEN\}\}/g, hidden.join("\n")).replace(/\{\{APPENDS\}\}/g, appends.join("\n")).replace(/\{\{CASTS\}\}/g, casts.join("\n")).replace(/\{\{RELATIONS\}\}/g, relations.join("\n\n"));
+  return {
+    path: `${options.baseModelPath}/${className}BaseModel.php`,
+    content,
+    type: "entity-base",
+    overwrite: true,
+    schemaName: schema.name
+  };
+}
+function generateRelation(propName, assoc, options) {
+  const methodName = toCamelCase(propName);
+  const targetClass = assoc.target ? toPascalCase(assoc.target) : "";
+  const fkName = toSnakeCase(propName) + "_id";
+  switch (assoc.relation) {
+    case "ManyToOne":
+      return `    /**
+     * Get the ${propName} that owns this model.
+     */
+    public function ${methodName}(): BelongsTo
+    {
+        return $this->belongsTo(${targetClass}::class, '${fkName}');
+    }`;
+    case "OneToOne":
+      if (assoc.mappedBy) {
+        return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): HasOne
+    {
+        return $this->hasOne(${targetClass}::class, '${toSnakeCase(assoc.mappedBy)}_id');
+    }`;
+      }
+      return `    /**
+     * Get the ${propName} that owns this model.
+     */
+    public function ${methodName}(): BelongsTo
+    {
+        return $this->belongsTo(${targetClass}::class, '${fkName}');
+    }`;
+    case "OneToMany":
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): HasMany
+    {
+        return $this->hasMany(${targetClass}::class, '${toSnakeCase(assoc.inversedBy ?? propName)}_id');
+    }`;
+    case "ManyToMany": {
+      const pivotTable = assoc.joinTable ?? `${toSnakeCase(propName)}_pivot`;
+      return `    /**
+     * The ${propName} that belong to this model.
+     */
+    public function ${methodName}(): BelongsToMany
+    {
+        return $this->belongsToMany(${targetClass}::class, '${pivotTable}')
+            ->withTimestamps();
+    }`;
+    }
+    case "MorphTo":
+      return `    /**
+     * Get the parent ${propName} model.
+     */
+    public function ${methodName}(): MorphTo
+    {
+        return $this->morphTo('${methodName}');
+    }`;
+    case "MorphOne":
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): MorphOne
+    {
+        return $this->morphOne(${targetClass}::class, '${assoc.morphName ?? propName}');
+    }`;
+    case "MorphMany":
+      return `    /**
+     * Get the ${propName} for this model.
+     */
+    public function ${methodName}(): MorphMany
+    {
+        return $this->morphMany(${targetClass}::class, '${assoc.morphName ?? propName}');
+    }`;
+    default:
+      return `    // TODO: Implement ${assoc.relation} relation for ${propName}`;
+  }
+}
+function generateFileRelation(propName, propDef) {
+  const methodName = toCamelCase(propName);
+  const relationType = propDef.multiple ? "MorphMany" : "MorphOne";
+  const relationMethod = propDef.multiple ? "morphMany" : "morphOne";
+  return `    /**
+     * Get the ${propName} file(s) for this model.
+     */
+    public function ${methodName}(): ${relationType}
+    {
+        return $this->${relationMethod}(FileUpload::class, 'uploadable')
+            ->where('attribute_name', '${propName}');
+    }`;
+}
+function generateEntityModel(schema, options, stubContent) {
+  const className = toPascalCase(schema.name);
+  const content = stubContent.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{MODEL_NAMESPACE\}\}/g, options.modelNamespace).replace(/\{\{CLASS_NAME\}\}/g, className);
+  return {
+    path: `${options.modelPath}/${className}.php`,
+    content,
+    type: "entity",
+    overwrite: false,
+    // Never overwrite user models
+    schemaName: schema.name
+  };
+}
+function getStubContent(stubName) {
+  const stubs = {
+    "base-model": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}};
+
+/**
+ * Base model class for all Omnify-generated models.
+ * Contains model mapping for polymorphic relations.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+
+use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\Relation;
+
+abstract class {{BASE_MODEL_CLASS}} extends Model
+{
+    /**
+     * Model class map for polymorphic relations.
+     */
+    protected static array $modelMap = [
+{{MODEL_MAP}}
+    ];
+
+    /**
+     * Boot the model and register morph map.
+     */
+    protected static function boot(): void
+    {
+        parent::boot();
+
+        // Register morph map for polymorphic relations
+        Relation::enforceMorphMap(static::$modelMap);
+    }
+
+    /**
+     * Get the model class for a given morph type.
+     */
+    public static function getModelClass(string $morphType): ?string
+    {
+        return static::$modelMap[$morphType] ?? null;
+    }
+}
+`,
+    "entity-base": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}};
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsTo;
+use Illuminate\\Database\\Eloquent\\Relations\\HasMany;
+use Illuminate\\Database\\Eloquent\\Relations\\HasOne;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsToMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphTo;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphOne;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphToMany;
+use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;
+{{IMPORTS}}
+
+{{DOC_COMMENT}}
+class {{CLASS_NAME}}BaseModel extends {{BASE_MODEL_CLASS}}
+{
+{{TRAITS}}
+    /**
+     * The table associated with the model.
+     */
+    protected $table = '{{TABLE_NAME}}';
+
+    /**
+     * The primary key for the model.
+     */
+    protected $primaryKey = '{{PRIMARY_KEY}}';
+
+{{KEY_TYPE}}
+{{INCREMENTING}}
+    /**
+     * Indicates if the model should be timestamped.
+     */
+    public $timestamps = {{TIMESTAMPS}};
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected $fillable = [
+{{FILLABLE}}
+    ];
+
+    /**
+     * The attributes that should be hidden for serialization.
+     */
+    protected $hidden = [
+{{HIDDEN}}
+    ];
+
+    /**
+     * The accessors to append to the model's array form.
+     */
+    protected $appends = [
+{{APPENDS}}
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     */
+    protected function casts(): array
+    {
+        return [
+{{CASTS}}
+        ];
+    }
+
+{{RELATIONS}}
+}
+`,
+    "entity-base-auth": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}};
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+
+use Illuminate\\Foundation\\Auth\\User as Authenticatable;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsTo;
+use Illuminate\\Database\\Eloquent\\Relations\\HasMany;
+use Illuminate\\Database\\Eloquent\\Relations\\HasOne;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsToMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphTo;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphOne;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
+use Illuminate\\Database\\Eloquent\\Relations\\MorphToMany;
+use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;
+use Illuminate\\Notifications\\Notifiable;
+{{IMPORTS}}
+
+{{DOC_COMMENT}}
+class {{CLASS_NAME}}BaseModel extends Authenticatable
+{
+    use Notifiable;
+{{TRAITS}}
+    /**
+     * The table associated with the model.
+     */
+    protected $table = '{{TABLE_NAME}}';
+
+    /**
+     * The primary key for the model.
+     */
+    protected $primaryKey = '{{PRIMARY_KEY}}';
+
+{{KEY_TYPE}}
+{{INCREMENTING}}
+    /**
+     * Indicates if the model should be timestamped.
+     */
+    public $timestamps = {{TIMESTAMPS}};
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected $fillable = [
+{{FILLABLE}}
+    ];
+
+    /**
+     * The attributes that should be hidden for serialization.
+     */
+    protected $hidden = [
+{{HIDDEN}}
+    ];
+
+    /**
+     * The accessors to append to the model's array form.
+     */
+    protected $appends = [
+{{APPENDS}}
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     */
+    protected function casts(): array
+    {
+        return [
+{{CASTS}}
+        ];
+    }
+
+{{RELATIONS}}
+}
+`,
+    "entity": `<?php
+
+namespace {{MODEL_NAMESPACE}};
+
+use {{BASE_MODEL_NAMESPACE}}\\{{CLASS_NAME}}BaseModel;
+use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
+
+/**
+ * {{CLASS_NAME}} Model
+ *
+ * This file is generated once and can be customized.
+ * Add your custom methods and logic here.
+ */
+class {{CLASS_NAME}} extends {{CLASS_NAME}}BaseModel
+{
+    use HasFactory;
+
+    /**
+     * Create a new model instance.
+     */
+    public function __construct(array $attributes = [])
+    {
+        parent::__construct($attributes);
+    }
+
+    // Add your custom methods here
+}
+`
+  };
+  return stubs[stubName] ?? "";
+}
+function generateModels(schemas, options) {
+  const resolved = resolveOptions(options);
+  const models = [];
+  models.push(generateBaseModel(schemas, resolved, getStubContent("base-model")));
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      continue;
+    }
+    models.push(generateEntityBaseModel(
+      schema,
+      schemas,
+      resolved,
+      getStubContent("entity-base"),
+      getStubContent("entity-base-auth")
+    ));
+    models.push(generateEntityModel(schema, resolved, getStubContent("entity")));
+  }
+  return models;
+}
+function getModelPath(model) {
+  return model.path;
+}
+
 // src/plugin.ts
 var LARAVEL_CONFIG_SCHEMA = {
   fields: [
@@ -695,6 +1275,30 @@ var LARAVEL_CONFIG_SCHEMA = {
       default: "database/migrations",
       group: "output"
     },
+    {
+      key: "modelsPath",
+      type: "path",
+      label: "Models Path",
+      description: "Directory for user-editable model files",
+      default: "app/Models",
+      group: "output"
+    },
+    {
+      key: "baseModelsPath",
+      type: "path",
+      label: "Base Models Path",
+      description: "Directory for auto-generated base model files",
+      default: "app/Models/OmnifyBase",
+      group: "output"
+    },
+    {
+      key: "generateModels",
+      type: "boolean",
+      label: "Generate Models",
+      description: "Generate Eloquent model classes",
+      default: true,
+      group: "options"
+    },
     {
       key: "connection",
       type: "string",
@@ -705,41 +1309,69 @@ var LARAVEL_CONFIG_SCHEMA = {
     }
   ]
 };
-function resolveOptions(options) {
+function resolveOptions2(options) {
   return {
     migrationsPath: options?.migrationsPath ?? "database/migrations",
+    modelsPath: options?.modelsPath ?? "app/Models",
+    baseModelsPath: options?.baseModelsPath ?? "app/Models/OmnifyBase",
+    modelNamespace: options?.modelNamespace ?? "App\\Models",
+    baseModelNamespace: options?.baseModelNamespace ?? "App\\Models\\OmnifyBase",
+    generateModels: options?.generateModels ?? true,
     connection: options?.connection,
     timestamp: options?.timestamp
   };
 }
 function laravelPlugin(options) {
-  const resolved = resolveOptions(options);
+  const resolved = resolveOptions2(options);
+  const migrationGenerator = {
+    name: "laravel-migrations",
+    description: "Generate Laravel migration files",
+    generate: async (ctx) => {
+      const migrationOptions = {
+        connection: resolved.connection,
+        timestamp: resolved.timestamp
+      };
+      const migrations = generateMigrations(ctx.schemas, migrationOptions);
+      return migrations.map((migration) => ({
+        path: getMigrationPath(migration, resolved.migrationsPath),
+        content: migration.content,
+        type: "migration",
+        metadata: {
+          tableName: migration.tables[0],
+          migrationType: migration.type
+        }
+      }));
+    }
+  };
+  const modelGenerator = {
+    name: "laravel-models",
+    description: "Generate Eloquent model classes",
+    generate: async (ctx) => {
+      const modelOptions = {
+        modelNamespace: resolved.modelNamespace,
+        baseModelNamespace: resolved.baseModelNamespace,
+        modelPath: resolved.modelsPath,
+        baseModelPath: resolved.baseModelsPath
+      };
+      const models = generateModels(ctx.schemas, modelOptions);
+      return models.map((model) => ({
+        path: getModelPath(model),
+        content: model.content,
+        type: "model",
+        // Skip writing user models if they already exist
+        skipIfExists: !model.overwrite,
+        metadata: {
+          modelType: model.type,
+          schemaName: model.schemaName
+        }
+      }));
+    }
+  };
   return {
     name: "@famgia/omnify-laravel",
-    version: "0.0.13",
+    version: "0.0.14",
     configSchema: LARAVEL_CONFIG_SCHEMA,
-    generators: [
-      {
-        name: "laravel-migrations",
-        description: "Generate Laravel migration files",
-        generate: async (ctx) => {
-          const migrationOptions = {
-            connection: resolved.connection,
-            timestamp: resolved.timestamp
-          };
-          const migrations = generateMigrations(ctx.schemas, migrationOptions);
-          return migrations.map((migration) => ({
-            path: getMigrationPath(migration, resolved.migrationsPath),
-            content: migration.content,
-            type: "migration",
-            metadata: {
-              tableName: migration.tables[0],
-              migrationType: migration.type
-            }
-          }));
-        }
-      }
-    ]
+    generators: resolved.generateModels ? [migrationGenerator, modelGenerator] : [migrationGenerator]
   };
 }
 // Annotate the CommonJS export names for ESM import in node: