@exium/cli 1.0.0-rc.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Exium Framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# Exium CLI
+
+CLI for scaffolding Exium microservices.
+
+Install globally:
+
+```bash
+npm install -g @exium/cli
+```
+
+Create a service:
+
+```bash
+exium new order-management
+```
+
+Create a service with an explicit aggregate/entity name:
+
+```bash
+exium new order-management --entity Order
+```
+
+The generated service depends on `@exium/core` and starts with a default aggregate, application handlers, MikroORM persistence adapter, and external HTTP controller.

package/dist/index.js

@@ -0,0 +1,698 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/new.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_child_process = require("child_process");
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+
+// src/utils/names.ts
+function toKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascal(str) {
+  return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function pluralize(str) {
+  if (str.endsWith("y") && !/[aeiou]y$/.test(str)) {
+    return str.slice(0, -1) + "ies";
+  }
+  if (/s|sh|ch|x|z$/.test(str)) return str + "es";
+  return str + "s";
+}
+function buildNames(serviceName, entityName) {
+  const svc = toKebab(serviceName);
+  const ent = toKebab(entityName);
+  return {
+    serviceName: svc,
+    ServiceName: toPascal(svc),
+    entityName: ent,
+    EntityName: toPascal(ent),
+    entityNames: pluralize(ent),
+    EntityNames: toPascal(pluralize(ent))
+  };
+}
+
+// src/templates/config.ts
+function packageJson(n) {
+  return JSON.stringify(
+    {
+      name: n.serviceName,
+      version: "0.0.1",
+      private: true,
+      scripts: {
+        build: "tsc -p tsconfig.json",
+        "build:watch": "tsc -p tsconfig.json --watch",
+        start: "node dist/main.js",
+        "start:dev": "ts-node -r tsconfig-paths/register src/main.ts"
+      },
+      dependencies: {
+        "@exium/core": "^1.0.0-rc.0",
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/config": "^4.0.0",
+        "@nestjs/platform-express": "^11.0.0",
+        "@mikro-orm/core": "^7.0.0",
+        "@mikro-orm/mongodb": "^7.0.0",
+        "@mikro-orm/nestjs": "^7.0.0",
+        "@mikro-orm/postgresql": "^7.0.0",
+        "class-validator": "^0.15.0",
+        "class-transformer": "^0.5.0",
+        "nestjs-pino": "^4.6.0",
+        pino: "^10.0.0",
+        "pino-http": "^11.0.0",
+        "pino-pretty": "^13.0.0",
+        "reflect-metadata": "^0.2.0",
+        rxjs: "^7.8.0",
+        uuid: "^14.0.0"
+      },
+      devDependencies: {
+        "@types/node": "^22.0.0",
+        "ts-node": "^10.9.0",
+        "tsconfig-paths": "^4.2.0",
+        typescript: "^6.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function tsConfig() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        lib: ["ES2022"],
+        outDir: "dist",
+        rootDir: "src",
+        strict: true,
+        ignoreDeprecations: "6.0",
+        strictNullChecks: true,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        skipLibCheck: true,
+        declaration: true,
+        declarationMap: true,
+        sourceMap: true,
+        resolveJsonModule: true,
+        paths: { "@/*": ["./src/*"] }
+      },
+      include: ["src"],
+      exclude: ["node_modules", "dist"]
+    },
+    null,
+    2
+  );
+}
+function envExample(n) {
+  return `# ${n.ServiceName} Service \u2014 Ortam De\u011Fi\u015Fkenleri
+
+EXIUM_DB_DRIVER=postgres
+EXIUM_DB_URL=postgresql://postgres:postgres@localhost:5432/${n.serviceName.replace(/-/g, "_")}
+
+# Opsiyonel
+# EXIUM_RABBITMQ_URL=amqp://localhost:5672
+# EXIUM_REDIS_URL=redis://localhost:6379
+
+PORT=3000
+`;
+}
+
+// src/templates/core.ts
+function mainTs(n) {
+  return `import 'reflect-metadata';
+import { createExiumApp } from '@exium/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await createExiumApp({
+    serviceName: '${n.serviceName}',
+    module: AppModule,
+    port: Number(process.env.PORT) || 3000,
+  });
+
+  await app.start();
+}
+
+bootstrap();
+`;
+}
+function appModuleTs(n) {
+  return `import { Module } from '@nestjs/common';
+import { ExiumModule } from '@exium/core';
+import { ${n.EntityNames}Controller } from './api/${n.entityNames}.controller';
+import { Create${n.EntityName}CommandHandler } from './application/commands/create-${n.entityName}/create-${n.entityName}.handler';
+import { Get${n.EntityNames}QueryHandler } from './application/queries/get-${n.entityNames}/get-${n.entityNames}.handler';
+import { ${n.EntityName}Repository } from './domain/${n.entityName}.repository';
+import { ${n.EntityName}RepositoryAdapter } from './infrastructure/persistence/${n.entityName}.repository.adapter';
+import { ${n.EntityName}Finder } from './application/ports/${n.entityName}.finder';
+import { ${n.EntityName}FinderAdapter } from './infrastructure/persistence/${n.entityName}-finder.adapter';
+import { ${n.EntityName}Mapper } from './infrastructure/persistence/${n.entityName}.mapper';
+import { ${n.EntityName}OrmEntity } from './infrastructure/persistence/${n.entityName}.orm-entity';
+
+@Module({
+  imports: [
+    ExiumModule.forRoot({
+      serviceName: '${n.serviceName}',
+      infrastructure: {
+        persistence: {
+          driver: 'postgres',
+          entities: [${n.EntityName}OrmEntity],
+          outbox: {
+            enabled: false,
+          },
+        },
+      },
+    }),
+  ],
+  controllers: [${n.EntityNames}Controller],
+  providers: [
+    Create${n.EntityName}CommandHandler,
+    Get${n.EntityNames}QueryHandler,
+    ${n.EntityName}Mapper,
+    { provide: ${n.EntityName}Repository, useClass: ${n.EntityName}RepositoryAdapter },
+    { provide: ${n.EntityName}Finder, useClass: ${n.EntityName}FinderAdapter },
+  ],
+})
+export class AppModule {}
+`;
+}
+
+// src/templates/domain.ts
+function entityIdTs(n) {
+  return `import { Id } from '@exium/core';
+
+export class ${n.EntityName}Id extends Id {
+  constructor(value: string) {
+    super(value);
+  }
+}
+`;
+}
+function aggregateTs(n) {
+  return `import { AuditableAggregateRoot } from '@exium/core';
+import { ${n.EntityName}Id } from './${n.entityName}-id.value-object';
+import { ${n.EntityName}CreatedEvent } from './${n.entityName}-created.event';
+
+interface Rehydrate${n.EntityName}Props {
+  readonly id: ${n.EntityName}Id;
+  readonly name: string;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+  readonly version: number;
+}
+
+export class ${n.EntityName} extends AuditableAggregateRoot<${n.EntityName}Id> {
+  private _name: string;
+
+  protected constructor(
+    id: ${n.EntityName}Id,
+    name: string,
+    createdAt = new Date(),
+    updatedAt = new Date(),
+    version = 1,
+  ) {
+    super(id, createdAt, updatedAt, version);
+    this._name = name;
+  }
+
+  get name(): string {
+    return this._name;
+  }
+
+  static create(id: ${n.EntityName}Id, name: string): ${n.EntityName} {
+    const entity = new ${n.EntityName}(id, name);
+    entity.raise(new ${n.EntityName}CreatedEvent(id, name));
+    return entity;
+  }
+
+  static rehydrate(props: Rehydrate${n.EntityName}Props): ${n.EntityName} {
+    return new ${n.EntityName}(
+      props.id,
+      props.name,
+      props.createdAt,
+      props.updatedAt,
+      props.version,
+    );
+  }
+}
+`;
+}
+function domainEventTs(n) {
+  return `import { DomainEvent } from '@exium/core';
+import { ${n.EntityName}Id } from './${n.entityName}-id.value-object';
+
+export class ${n.EntityName}CreatedEvent extends DomainEvent {
+  readonly name = '${n.EntityName}Created';
+
+  constructor(
+    public readonly ${n.entityName}Id: ${n.EntityName}Id,
+    public readonly ${n.entityName}Name: string,
+  ) {
+    super(${n.entityName}Id.value);
+  }
+}
+`;
+}
+function repositoryTs(n) {
+  return `import { type Repository } from '@exium/core';
+import { ${n.EntityName} } from './${n.entityName}.aggregate';
+import { ${n.EntityName}Id } from './${n.entityName}-id.value-object';
+
+export abstract class ${n.EntityName}Repository implements Repository<${n.EntityName}, ${n.EntityName}Id> {
+  abstract findById(id: ${n.EntityName}Id): Promise<${n.EntityName} | null>;
+  abstract findByIds(ids: readonly ${n.EntityName}Id[]): Promise<${n.EntityName}[]>;
+  abstract exists(id: ${n.EntityName}Id): Promise<boolean>;
+  abstract save(aggregate: ${n.EntityName}): Promise<void>;
+  abstract delete(id: ${n.EntityName}Id): Promise<void>;
+  abstract findByName(name: string): Promise<${n.EntityName} | null>;
+}
+`;
+}
+
+// src/templates/application.ts
+function readModelTs(n) {
+  return `import { type ReadModel } from '@exium/core';
+
+export class ${n.EntityName}ReadModel implements ReadModel {
+  constructor(
+    readonly id: string,
+    readonly name: string,
+    readonly createdAt: Date,
+  ) {}
+}
+`;
+}
+function finderPortTs(n) {
+  return `import { type Finder, type Page, type PageRequest } from '@exium/core';
+import { ${n.EntityName}ReadModel } from '../dtos/${n.entityName}-read.model';
+
+export abstract class ${n.EntityName}Finder implements Finder {
+  abstract findAll(pageRequest: PageRequest): Promise<Page<${n.EntityName}ReadModel>>;
+}
+`;
+}
+function createCommandTs(n) {
+  return `import { Command, Transactional } from '@exium/core';
+
+@Transactional()
+export class Create${n.EntityName}Command extends Command<string> {
+  constructor(public readonly name: string) {
+    super();
+  }
+}
+`;
+}
+function createHandlerTs(n) {
+  return `import { Injectable } from '@nestjs/common';
+import {
+  CommandHandler,
+  Failure,
+  HandleCommand,
+  Result,
+  type ResultType,
+} from '@exium/core';
+import { Create${n.EntityName}Command } from './create-${n.entityName}.command';
+import { ${n.EntityName} } from '../../../domain/${n.entityName}.aggregate';
+import { ${n.EntityName}Id } from '../../../domain/${n.entityName}-id.value-object';
+import { ${n.EntityName}Repository } from '../../../domain/${n.entityName}.repository';
+
+@Injectable()
+@HandleCommand(Create${n.EntityName}Command)
+export class Create${n.EntityName}CommandHandler extends CommandHandler<Create${n.EntityName}Command> {
+  constructor(private readonly ${n.entityName}Repository: ${n.EntityName}Repository) {
+    super();
+  }
+
+  async handle(command: Create${n.EntityName}Command): Promise<ResultType<string>> {
+    const existing = await this.${n.entityName}Repository.findByName(command.name);
+
+    if (existing) {
+      return Result.fail(
+        Failure.conflict(
+          '${n.EntityName.toUpperCase()}_ALREADY_EXISTS',
+          \`"\${command.name}" ad\u0131yla kay\u0131tl\u0131 bir ${n.entityName} zaten var.\`,
+          { name: command.name },
+        ),
+      );
+    }
+
+    const id = ${n.EntityName}Id.generate();
+    const entity = ${n.EntityName}.create(id, command.name);
+
+    await this.${n.entityName}Repository.save(entity);
+
+    return Result.ok(id.value);
+  }
+}
+`;
+}
+function getQueryTs(n) {
+  return `import { Query, type Page, type PageRequest } from '@exium/core';
+import { ${n.EntityName}ReadModel } from '../../dtos/${n.entityName}-read.model';
+
+export class Get${n.EntityNames}Query extends Query<Page<${n.EntityName}ReadModel>> {
+  constructor(public readonly pageRequest: PageRequest) {
+    super();
+  }
+}
+`;
+}
+function getHandlerTs(n) {
+  return `import { Injectable } from '@nestjs/common';
+import { HandleQuery, QueryHandler, Result, type Page, type ResultType } from '@exium/core';
+import { Get${n.EntityNames}Query } from './get-${n.entityNames}.query';
+import { ${n.EntityName}ReadModel } from '../../dtos/${n.entityName}-read.model';
+import { ${n.EntityName}Finder } from '../../ports/${n.entityName}.finder';
+
+@Injectable()
+@HandleQuery(Get${n.EntityNames}Query)
+export class Get${n.EntityNames}QueryHandler extends QueryHandler<Get${n.EntityNames}Query> {
+  constructor(private readonly ${n.entityName}Finder: ${n.EntityName}Finder) {
+    super();
+  }
+
+  async handle(query: Get${n.EntityNames}Query): Promise<ResultType<Page<${n.EntityName}ReadModel>>> {
+    const page = await this.${n.entityName}Finder.findAll(query.pageRequest);
+
+    return Result.ok(page);
+  }
+}
+`;
+}
+
+// src/templates/infrastructure.ts
+function ormEntityTs(n) {
+  return `import { defineEntity, p } from '@mikro-orm/core';
+
+const ${n.EntityName}OrmEntitySchema = defineEntity({
+  name: '${n.EntityName}OrmEntity',
+  tableName: '${n.entityNames}',
+  properties: {
+    id: p.string().primary(),
+    name: p.string(),
+    createdAt: p.datetime(),
+    updatedAt: p.datetime().onUpdate(() => new Date()),
+    version: p.integer(),
+  },
+});
+
+export class ${n.EntityName}OrmEntity extends ${n.EntityName}OrmEntitySchema.class {}
+
+${n.EntityName}OrmEntitySchema.setClass(${n.EntityName}OrmEntity);
+`;
+}
+function mapperTs(n) {
+  return `import { Injectable } from '@nestjs/common';
+import { type PersistenceMapper } from '@exium/core';
+import { ${n.EntityName} } from '../../domain/${n.entityName}.aggregate';
+import { ${n.EntityName}Id } from '../../domain/${n.entityName}-id.value-object';
+import { ${n.EntityName}OrmEntity } from './${n.entityName}.orm-entity';
+
+@Injectable()
+export class ${n.EntityName}Mapper implements PersistenceMapper<${n.EntityName}, ${n.EntityName}Id, ${n.EntityName}OrmEntity, string> {
+  toDomain(persistence: ${n.EntityName}OrmEntity): ${n.EntityName} {
+    return ${n.EntityName}.rehydrate({
+      id: ${n.EntityName}Id.of(persistence.id),
+      name: persistence.name,
+      createdAt: persistence.createdAt,
+      updatedAt: persistence.updatedAt,
+      version: persistence.version,
+    });
+  }
+
+  toPersistence(domain: ${n.EntityName}): ${n.EntityName}OrmEntity {
+    const entity = new ${n.EntityName}OrmEntity();
+    entity.id = domain.id.value;
+    entity.name = domain.name;
+    entity.createdAt = domain.createdAt;
+    entity.updatedAt = domain.updatedAt;
+    entity.version = domain.version;
+    return entity;
+  }
+
+  toPersistenceId(id: ${n.EntityName}Id): string {
+    return id.value;
+  }
+
+  getPersistenceId(domain: ${n.EntityName}): string {
+    return domain.id.value;
+  }
+}
+`;
+}
+function repositoryAdapterTs(n) {
+  return `import { Injectable } from '@nestjs/common';
+import { EntityManager } from '@mikro-orm/core';
+import { MikroOrmAggregateRepository, UnitOfWork } from '@exium/core';
+import { ${n.EntityName} } from '../../domain/${n.entityName}.aggregate';
+import { ${n.EntityName}Id } from '../../domain/${n.entityName}-id.value-object';
+import { ${n.EntityName}Repository } from '../../domain/${n.entityName}.repository';
+import { ${n.EntityName}OrmEntity } from './${n.entityName}.orm-entity';
+import { ${n.EntityName}Mapper } from './${n.entityName}.mapper';
+
+@Injectable()
+export class ${n.EntityName}RepositoryAdapter
+  extends MikroOrmAggregateRepository<${n.EntityName}, ${n.EntityName}Id, ${n.EntityName}OrmEntity, string>
+  implements ${n.EntityName}Repository
+{
+  constructor(
+    em: EntityManager,
+    private readonly ${n.entityName}Mapper: ${n.EntityName}Mapper,
+    uow: UnitOfWork,
+  ) {
+    super(${n.EntityName}OrmEntity, em, ${n.entityName}Mapper, uow);
+  }
+
+  async findByName(name: string): Promise<${n.EntityName} | null> {
+    const raw = await this.em.findOne(${n.EntityName}OrmEntity, { name } as any);
+    if (!raw) return null;
+    return this.${n.entityName}Mapper.toDomain(raw);
+  }
+}
+`;
+}
+function finderAdapterTs(n) {
+  return `import { Injectable } from '@nestjs/common';
+import { EntityManager } from '@mikro-orm/core';
+import { Page, type PageRequest } from '@exium/core';
+import { ${n.EntityName}Finder } from '../../application/ports/${n.entityName}.finder';
+import { ${n.EntityName}ReadModel } from '../../application/dtos/${n.entityName}-read.model';
+import { ${n.EntityName}OrmEntity } from './${n.entityName}.orm-entity';
+
+@Injectable()
+export class ${n.EntityName}FinderAdapter implements ${n.EntityName}Finder {
+  constructor(private readonly em: EntityManager) {}
+
+  async findAll(pageRequest: PageRequest): Promise<Page<${n.EntityName}ReadModel>> {
+    const [rows, totalItems] = await Promise.all([
+      this.em.find(${n.EntityName}OrmEntity, {}, {
+        limit: pageRequest.size,
+        offset: pageRequest.offset,
+        orderBy: { createdAt: 'desc' } as any,
+      }),
+      this.em.count(${n.EntityName}OrmEntity, {}),
+    ]);
+
+    const items = rows.map(
+      (row) => new ${n.EntityName}ReadModel(row.id, row.name, row.createdAt),
+    );
+
+    return Page.of(items, pageRequest, totalItems);
+  }
+}
+`;
+}
+
+// src/templates/api.ts
+function createRequestTs(n) {
+  return `import { IsString, IsNotEmpty } from 'class-validator';
+
+export class Create${n.EntityName}Request {
+  @IsString()
+  @IsNotEmpty()
+  name!: string;
+}
+`;
+}
+function controllerTs(n) {
+  return `import { Controller, Get, Post, Body, Query } from '@nestjs/common';
+import { CommandExecutor, ExternalApi, PageRequest, QueryExecutor } from '@exium/core';
+import { Create${n.EntityName}Command } from '../application/commands/create-${n.entityName}/create-${n.entityName}.command';
+import { Get${n.EntityNames}Query } from '../application/queries/get-${n.entityNames}/get-${n.entityNames}.query';
+import { Create${n.EntityName}Request } from './dtos/create-${n.entityName}.request';
+
+@Controller('${n.entityNames}')
+@ExternalApi({
+  name: '${n.entityNames}',
+  owner: '${n.serviceName}',
+  tags: ['${n.entityNames}'],
+})
+export class ${n.EntityNames}Controller {
+  constructor(
+    private readonly commandExecutor: CommandExecutor,
+    private readonly queryExecutor: QueryExecutor,
+  ) {}
+
+  @Post()
+  create(@Body() body: Create${n.EntityName}Request) {
+    return this.commandExecutor.execute(
+      new Create${n.EntityName}Command(body.name),
+    );
+  }
+
+  @Get()
+  list(
+    @Query('page') page = '1',
+    @Query('size') size = '10',
+  ) {
+    const pageRequest = PageRequest.of(Number(page), Number(size));
+
+    if (pageRequest.isFailure()) {
+      return pageRequest;
+    }
+
+    return this.queryExecutor.execute(
+      new Get${n.EntityNames}Query(pageRequest.value),
+    );
+  }
+}
+`;
+}
+
+// src/commands/new.ts
+function write(filePath, content) {
+  import_fs.default.mkdirSync(import_path.default.dirname(filePath), { recursive: true });
+  import_fs.default.writeFileSync(filePath, content, "utf-8");
+}
+async function runNew(serviceName, options) {
+  const entityInput = options.entity ?? deriveEntityFromService(serviceName);
+  const n = buildNames(serviceName, entityInput);
+  const root = import_path.default.resolve(process.cwd(), n.serviceName);
+  console.log();
+  console.log(import_chalk.default.bold(`  Exium \u2014 yeni mikroservis olu\u015Fturuluyor`));
+  console.log(import_chalk.default.dim(`  Servis : ${import_chalk.default.white(n.serviceName)}`));
+  console.log(import_chalk.default.dim(`  Entity : ${import_chalk.default.white(n.EntityName)}`));
+  console.log(import_chalk.default.dim(`  Konum  : ${import_chalk.default.white(root)}`));
+  console.log();
+  if (import_fs.default.existsSync(root)) {
+    console.error(import_chalk.default.red(`  Hata: "${root}" dizini zaten var.`));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora.default)({ text: "Dosyalar olu\u015Fturuluyor\u2026", prefixText: "  " }).start();
+  try {
+    write(`${root}/package.json`, packageJson(n));
+    write(`${root}/tsconfig.json`, tsConfig());
+    write(`${root}/.env.example`, envExample(n));
+    write(`${root}/.gitignore`, "node_modules\ndist\n.env\n");
+    write(`${root}/src/main.ts`, mainTs(n));
+    write(`${root}/src/app.module.ts`, appModuleTs(n));
+    write(`${root}/src/domain/${n.entityName}-id.value-object.ts`, entityIdTs(n));
+    write(`${root}/src/domain/${n.entityName}.aggregate.ts`, aggregateTs(n));
+    write(`${root}/src/domain/${n.entityName}-created.event.ts`, domainEventTs(n));
+    write(`${root}/src/domain/${n.entityName}.repository.ts`, repositoryTs(n));
+    write(`${root}/src/application/dtos/${n.entityName}-read.model.ts`, readModelTs(n));
+    write(`${root}/src/application/ports/${n.entityName}.finder.ts`, finderPortTs(n));
+    write(
+      `${root}/src/application/commands/create-${n.entityName}/create-${n.entityName}.command.ts`,
+      createCommandTs(n)
+    );
+    write(
+      `${root}/src/application/commands/create-${n.entityName}/create-${n.entityName}.handler.ts`,
+      createHandlerTs(n)
+    );
+    write(
+      `${root}/src/application/queries/get-${n.entityNames}/get-${n.entityNames}.query.ts`,
+      getQueryTs(n)
+    );
+    write(
+      `${root}/src/application/queries/get-${n.entityNames}/get-${n.entityNames}.handler.ts`,
+      getHandlerTs(n)
+    );
+    write(`${root}/src/infrastructure/persistence/${n.entityName}.orm-entity.ts`, ormEntityTs(n));
+    write(`${root}/src/infrastructure/persistence/${n.entityName}.mapper.ts`, mapperTs(n));
+    write(
+      `${root}/src/infrastructure/persistence/${n.entityName}.repository.adapter.ts`,
+      repositoryAdapterTs(n)
+    );
+    write(
+      `${root}/src/infrastructure/persistence/${n.entityName}-finder.adapter.ts`,
+      finderAdapterTs(n)
+    );
+    write(`${root}/src/api/dtos/create-${n.entityName}.request.ts`, createRequestTs(n));
+    write(`${root}/src/api/${n.entityNames}.controller.ts`, controllerTs(n));
+    spinner.succeed(import_chalk.default.green("Dosyalar olu\u015Fturuldu."));
+  } catch (err) {
+    spinner.fail("Dosya olu\u015Fturma ba\u015Far\u0131s\u0131z.");
+    throw err;
+  }
+  if (!options.skipInstall) {
+    const installSpinner = (0, import_ora.default)({ text: "Ba\u011F\u0131ml\u0131l\u0131klar y\xFCkleniyor\u2026", prefixText: "  " }).start();
+    try {
+      (0, import_child_process.execSync)("npm install", { cwd: root, stdio: "ignore" });
+      installSpinner.succeed(import_chalk.default.green("Ba\u011F\u0131ml\u0131l\u0131klar y\xFCklendi."));
+    } catch {
+      installSpinner.warn(import_chalk.default.yellow("npm install ba\u015Far\u0131s\u0131z \u2014 manuel olarak \xE7al\u0131\u015Ft\u0131r."));
+    }
+  }
+  console.log();
+  console.log(import_chalk.default.bold("  Haz\u0131r!"));
+  console.log();
+  console.log(`  ${import_chalk.default.dim("$")} cd ${n.serviceName}`);
+  if (options.skipInstall) {
+    console.log(`  ${import_chalk.default.dim("$")} npm install`);
+  }
+  console.log(`  ${import_chalk.default.dim("$")} cp .env.example .env`);
+  console.log(`  ${import_chalk.default.dim("$")} npm run start:dev`);
+  console.log();
+  console.log(
+    import_chalk.default.dim(`  Sonraki ad\u0131m: src/domain/${n.entityName}.aggregate.ts dosyas\u0131n\u0131`) + import_chalk.default.dim(` domain'e g\xF6re d\xFCzenle.`)
+  );
+  console.log();
+}
+function deriveEntityFromService(serviceName) {
+  const parts = toKebab(serviceName).split("-");
+  return parts[0];
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("exium").description("Exium Framework CLI").version("1.0.0");
+program.command("new <service-name>").description("Yeni bir Exium mikroservisi olu\u015Fturur").option("-e, --entity <entity-name>", "\u0130lk entity ad\u0131 (belirtilmezse servis ad\u0131ndan t\xFCretilir)").option("--skip-install", "Ba\u011F\u0131ml\u0131l\u0131k kurulumunu atla").action((serviceName, options) => {
+  runNew(serviceName, options).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+});
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@exium/cli",
+  "version": "1.0.0-rc.0",
+  "description": "CLI for scaffolding Exium microservices",
+  "main": "./dist/index.js",
+  "bin": {
+    "exium": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=22.17.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "prepack": "npm run build",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "exium",
+    "nestjs",
+    "ddd",
+    "microservice",
+    "cli",
+    "scaffold"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yusuf218921/exium-framework.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/yusuf218921/exium-framework/issues"
+  },
+  "homepage": "https://github.com/yusuf218921/exium-framework/tree/main/cli#readme",
+  "author": "Yusuf Sönmez <yusufsonmez951@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  }
+}