@auto-engineer/server-generator-nestjs 0.11.16

package/src/codegen/templates/command/resolver.ts.ejs

@@ -0,0 +1,56 @@
+<%
+const command = commands[0];
+if (!command) return '';
+const mutationName = camelCase(sliceName);
+%>import { Mutation, Resolver, Args } from '@nestjs/graphql';
+import { Logger, Injectable } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { <%= pascalCase(command.type) %>Command } from './<%= toKebabCase(sliceName) %>.command';
+import { <%= pascalCase(command.type) %>Input } from './<%= toKebabCase(sliceName) %>.input';
+import { MutationResponse } from '../../shared/graphql-types';
+
+@Injectable()
+@Resolver()
+export class <%= pascalCase(command.type) %>Resolver {
+  private readonly logger = new Logger(<%= pascalCase(command.type) %>Resolver.name);
+
+  constructor(private readonly commandBus: CommandBus) {}
+
+  @Mutation(() => MutationResponse)
+  async <%= mutationName %>(
+    @Args({ name: 'input', type: () => <%= pascalCase(command.type) %>Input })
+    input: <%= pascalCase(command.type) %>Input
+  ): Promise<MutationResponse> {
+    try {
+      await this.commandBus.execute(
+        new <%= pascalCase(command.type) %>Command(
+        <% for (let i = 0; i < command.fields.length; i++) { const field = command.fields[i]; -%>
+          input.<%= field.name %>,
+        <% } -%>
+        )
+      );
+      this.logger.log(`Successfully executed: <%= mutationName %>`);
+      return { success: true };
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        this.logger.error(`Failed to execute <%= mutationName %>: ${error.message}`, error.stack);
+        return {
+          success: false,
+          error: {
+            type: error.name,
+            message: error.message,
+          },
+        };
+      }
+
+      this.logger.error('Failed to execute <%= mutationName %>: Unknown error');
+      return {
+        success: false,
+        error: {
+          type: 'UnknownError',
+          message: 'An unexpected error occurred',
+        },
+      };
+    }
+  }
+}

package/src/codegen/templates/entity/entity.ts.ejs

@@ -0,0 +1,35 @@
+<%
+function getOrmType(field) {
+  const cleanType = field.tsType.replace(/\s*\|\s*null\b/g, '').trim();
+  if (cleanType === 'string') return 'string';
+  if (cleanType === 'number') return 'number';
+  if (cleanType === 'boolean') return 'boolean';
+  if (cleanType === 'Date') return 'Date';
+  return 'string';
+}
+%>import { Entity, PrimaryKey, Property, Enum, Index } from '@mikro-orm/core';
+<% if (entity.enumImports.length > 0) { -%>
+import { <%= entity.enumImports.join(', ') %> } from '.';
+<% } -%>
+
+@Entity({ tableName: '<%= entity.tableName %>' })
+export class <%= entity.entityName %> {
+<% for (const field of entity.fields) { -%>
+<% if (field.isPrimary) { -%>
+  @PrimaryKey({ type: '<%= getOrmType(field) %>' })
+  <%= field.name %>!: <%= toTsFieldType(field.tsType) %>;
+
+<% } else if (field.isEnum && field.enumName) { -%>
+  @Enum(() => <%= field.enumName %>)
+<% if (field.indexed) { -%>
+  @Index()
+<% } -%>
+  <%= field.name %>!: <%= field.enumName %>;
+
+<% } else { -%>
+  @Property({ type: '<%= getOrmType(field) %>'<%= field.nullable ? ', nullable: true' : '' %> })
+  <%= field.name %><%= field.nullable ? '?' : '!' %>: <%= toTsFieldType(field.tsType) %><%= field.nullable ? ' | null' : '' %>;
+
+<% } -%>
+<% } -%>
+}

package/src/codegen/templates/entity/index.ts.ejs

@@ -0,0 +1,6 @@
+export * from './<%= toKebabCase(entity.entityName) %>.entity';
+<% if (entity.enumImports.length > 0) { -%>
+<% for (const enumName of entity.enumImports) { -%>
+export * from './<%= toKebabCase(enumName) %>.enum';
+<% } -%>
+<% } -%>

package/src/codegen/templates/module/app-module.ts.ejs

@@ -0,0 +1,65 @@
+import { Module, Logger } from '@nestjs/common';
+import { CqrsModule } from '@nestjs/cqrs';
+import { GraphQLModule } from '@nestjs/graphql';
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
+import { MikroOrmModule } from '@mikro-orm/nestjs';
+import { SqliteDriver } from '@mikro-orm/sqlite';
+import { Migrator } from '@mikro-orm/migrations';
+import { join } from 'path';
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+
+<% for (const flow of flows) { -%>
+import { <%= pascalCase(flow.name) %>Module } from './domain/<%= toKebabCase(flow.name) %>/<%= toKebabCase(flow.name) %>.module';
+import { <%= pascalCase(flow.name) %>Entity } from './domain/<%= toKebabCase(flow.name) %>/entities';
+<% } -%>
+
+const domainModules = [
+<% for (const flow of flows) { -%>
+  <%= pascalCase(flow.name) %>Module,
+<% } -%>
+];
+
+const entities = [
+<% for (const flow of flows) { -%>
+  <%= pascalCase(flow.name) %>Entity,
+<% } -%>
+];
+
+@Module({
+  imports: [
+    ...domainModules,
+    MikroOrmModule.forRoot({
+      entities,
+      dbName: process.env.NODE_ENV === 'test' ? ':memory:' : './db.sqlite',
+      driver: SqliteDriver,
+      allowGlobalContext: true,
+      debug: process.env.NODE_ENV !== 'production',
+      ensureDatabase: true,
+      extensions: [Migrator],
+      migrations: {
+        path: join(__dirname, 'migrations'),
+        glob: '!(*.d).{js,ts}',
+        transactional: true,
+        disableForeignKeys: false,
+        emit: 'ts',
+      },
+    }),
+    CqrsModule.forRoot(),
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
+      sortSchema: true,
+      playground: false,
+      introspection: true,
+      csrfPrevention: false,
+      plugins: [ApolloServerPluginLandingPageLocalDefault()],
+    }),
+  ],
+})
+export class AppModule {
+  private readonly logger = new Logger(AppModule.name);
+
+  constructor() {
+    this.logger.log('✅ Application module initialized');
+  }
+}

package/src/codegen/templates/module/domain-module.ts.ejs

@@ -0,0 +1,46 @@
+<%
+const moduleName = pascalCase(flowName) + 'Module';
+const entityName = pascalCase(flowName) + 'Entity';
+%>import { Module } from '@nestjs/common';
+import { CqrsModule } from '@nestjs/cqrs';
+import { MikroOrmModule } from '@mikro-orm/nestjs';
+import { <%= entityName %> } from './entities/<%= toKebabCase(entityName) %>.entity';
+<% for (const slice of slices) { -%>
+<% if (slice.type === 'command') { -%>
+import { <%= pascalCase(slice.name) %>Handler } from './<%= toKebabCase(slice.name) %>/<%= toKebabCase(slice.name) %>.handler';
+import { <%= pascalCase(slice.name) %>Resolver } from './<%= toKebabCase(slice.name) %>/<%= toKebabCase(slice.name) %>.resolver';
+<% } else if (slice.type === 'query') { -%>
+import { <%= pascalCase(slice.name) %>Handler } from './<%= toKebabCase(slice.name) %>/<%= toKebabCase(slice.name) %>.handler';
+import { <%= pascalCase(slice.name) %>Resolver } from './<%= toKebabCase(slice.name) %>/<%= toKebabCase(slice.name) %>.resolver';
+<% } -%>
+<% } -%>
+
+const CommandHandlers = [
+<% for (const slice of slices) { -%>
+<% if (slice.type === 'command') { -%>
+  <%= pascalCase(slice.name) %>Handler,
+<% } -%>
+<% } -%>
+];
+
+const QueryHandlers = [
+<% for (const slice of slices) { -%>
+<% if (slice.type === 'query') { -%>
+  <%= pascalCase(slice.name) %>Handler,
+<% } -%>
+<% } -%>
+];
+
+const Resolvers = [
+<% for (const slice of slices) { -%>
+<% if (slice.type === 'command' || slice.type === 'query') { -%>
+  <%= pascalCase(slice.name) %>Resolver,
+<% } -%>
+<% } -%>
+];
+
+@Module({
+  imports: [CqrsModule, MikroOrmModule.forFeature([<%= entityName %>])],
+  providers: [...CommandHandlers, ...QueryHandlers, ...Resolvers],
+})
+export class <%= moduleName %> {}

package/src/codegen/templates/query/handler.ts.ejs

@@ -0,0 +1,25 @@
+<%
+const entityName = pascalCase(flowName) + 'Entity';
+const typeName = projectionType || pascalCase(sliceName) + 'State';
+const isSingleton = projectionSingleton === true;
+%>import { QueryHandler, IQueryHandler } from '@nestjs/cqrs';
+import { InjectRepository } from '@mikro-orm/nestjs';
+import { EntityRepository } from '@mikro-orm/core';
+import { <%= pascalCase(sliceName) %>Query } from './<%= toKebabCase(sliceName) %>.query';
+import { <%= entityName %> } from '../entities/<%= toKebabCase(entityName) %>.entity';
+
+@QueryHandler(<%= pascalCase(sliceName) %>Query)
+export class <%= pascalCase(sliceName) %>Handler implements IQueryHandler<<%= pascalCase(sliceName) %>Query> {
+  constructor(
+    @InjectRepository(<%= entityName %>)
+    private readonly repository: EntityRepository<<%= entityName %>>,
+  ) {}
+
+  async execute(): Promise<<%= entityName %><%= isSingleton ? ' | null' : '[]' %>> {
+<% if (isSingleton) { -%>
+    return this.repository.findOne({});
+<% } else { -%>
+    return this.repository.findAll();
+<% } -%>
+  }
+}

package/src/codegen/templates/query/query.ts.ejs

@@ -0,0 +1 @@
+export class <%= pascalCase(sliceName) %>Query {}

package/src/codegen/templates/query/resolver.ts.ejs

@@ -0,0 +1,20 @@
+<%
+const typeName = projectionType || pascalCase(sliceName) + 'State';
+const queryName = camelCase(projectionName || sliceName);
+const isSingleton = projectionSingleton === true;
+%>import { Query, Resolver } from '@nestjs/graphql';
+import { Injectable } from '@nestjs/common';
+import { QueryBus } from '@nestjs/cqrs';
+import { <%= pascalCase(sliceName) %>Query } from './<%= toKebabCase(sliceName) %>.query';
+import { <%= typeName %> } from './<%= toKebabCase(sliceName) %>.type';
+
+@Injectable()
+@Resolver()
+export class <%= pascalCase(sliceName) %>Resolver {
+  constructor(private readonly queryBus: QueryBus) {}
+
+  @Query(() => <%= isSingleton ? typeName : `[${typeName}]` %>)
+  async <%= queryName %>(): Promise<<%= typeName %><%= isSingleton ? ' | null' : '[]' %>> {
+    return this.queryBus.execute(new <%= pascalCase(sliceName) %>Query());
+  }
+}

package/src/codegen/templates/query/type.ts.ejs

@@ -0,0 +1,24 @@
+<%
+const state = states[0] || message;
+if (!state || !state.fields) return '';
+const usesID = state.fields.some(f => graphqlType(f.tsType) === 'ID');
+const usesFloat = state.fields.some(f => fieldUsesFloat(f.tsType));
+const usesJSON = state.fields.some(f => fieldUsesJSON(f.tsType));
+const enumList = collectEnumNames(state.fields);
+const typeName = projectionType || pascalCase(sliceName) + 'State';
+%>import { ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesFloat) { %>, Float<% } %> } from '@nestjs/graphql';
+<% if (usesJSON) { -%>
+import GraphQLJSON from 'graphql-type-json';
+<% } -%>
+<% if (enumList.length > 0) { -%>
+import { <%= enumList.join(', ') %> } from '../entities';
+<% } -%>
+
+@ObjectType()
+export class <%= typeName %> {
+<% for (const field of state.fields) { -%>
+  @Field(() => <%= graphqlType(field.tsType) %><%= isNullable(field.tsType) ? ', { nullable: true }' : '' %>)
+  <%= field.name %><%= isNullable(field.tsType) ? '?' : '!' %>: <%= toTsFieldType(field.tsType) %><%= isNullable(field.tsType) ? ' | null' : '' %>;
+
+<% } -%>
+}

package/src/codegen/types.ts

@@ -0,0 +1,39 @@
+import type { CommandExample, ErrorRef, EventExample, StateExample } from './extract/step-types';
+
+export type { CommandExample, ErrorRef, EventExample, StateExample };
+
+export interface Message {
+  type: string;
+  fields: Field[];
+  source?: 'when' | 'given' | 'then';
+  sourceFlowName?: string;
+  sourceSliceName?: string;
+}
+
+export interface Field {
+  name: string;
+  tsType: string;
+  required: boolean;
+}
+
+export interface MessageDefinition {
+  type: 'command' | 'event' | 'state';
+  name: string;
+  fields?: Array<{
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+    defaultValue?: unknown;
+  }>;
+  metadata?: unknown;
+  description?: string;
+}
+
+export interface GwtCondition {
+  given?: Array<EventExample | StateExample>;
+  when: CommandExample | EventExample[];
+  then: Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>;
+  description?: string;
+  ruleDescription?: string;
+}

package/src/codegen/utils/path.ts

@@ -0,0 +1,20 @@
+import { existsSync } from 'fs';
+import { mkdir } from 'fs/promises';
+import path from 'path';
+
+export function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/\s+/g, '-')
+    .toLowerCase();
+}
+
+export function ensureDirPath(...segments: string[]): string {
+  return path.join(...segments);
+}
+
+export async function ensureDirExists(dirPath: string): Promise<void> {
+  if (!existsSync(dirPath)) {
+    await mkdir(dirPath, { recursive: true });
+  }
+}