@memberjunction/codegen-lib v2.48.0

@memberjunction/codegen-lib

🚀 The most sophisticated code generation engine you've ever seen - automatically transforms your database schema into a complete, type-safe, full-stack application with AI-powered intelligence.

What Makes This Badass?

MemberJunction's CodeGen doesn't just generate boilerplate code. It's an AI-powered, metadata-driven architecture that creates bulletproof, production-ready applications from your database schema with zero manual intervention.

🧠 AI-Powered Intelligence

• CHECK Constraint Translation: Our AI automatically translates complex SQL CHECK constraints into perfect TypeScript union types and Zod validation schemas
• Smart Type Inference: Analyzes relationships and generates contextually appropriate Angular form controls (dropdowns, search boxes, checkboxes)
• Intelligent Naming: AI-driven naming conventions ensure your generated code follows best practices

⚡ Synchronization Across Everything

Watch your database changes instantly propagate through your entire stack:

Database Schema Change → TypeScript Entities → Angular Forms → SQL Procedures → GraphQL Schema

One command. Complete synchronization. Zero breaking changes.

🎯 What Gets Generated (Automatically)

• TypeScript Entity Classes with full type safety and validation
• Angular Form Components with proper field types and validation
• SQL Stored Procedures for all CRUD operations
• Database Views with optimized joins and indexing
• GraphQL Schemas and resolvers
• Zod Validation Schemas from SQL constraints
• Complete API Endpoints with type-safe parameters

Installation

npm install @memberjunction/codegen-lib

The Magic in Action

From This SQL Constraint:

ALTER TABLE [AIPrompt]
ADD [PromptRole] nvarchar(20) NOT NULL
    CONSTRAINT [CK_AIPrompt_PromptRole] CHECK ([PromptRole] IN (N'System', N'User', N'Assistant', N'SystemOrUser'))

To This TypeScript (Automatically):

PromptRole: z.union([
    z.literal('System'), 
    z.literal('User'), 
    z.literal('Assistant'), 
    z.literal('SystemOrUser')
]).describe('Determines how the prompt is used in conversation...')

To This Angular Form (Automatically):

<mj-form-field 
    [record]="record"
    FieldName="PromptRole"
    Type="dropdownlist"  // AI chose dropdown based on constraint
    [EditMode]="EditMode"
></mj-form-field>

To This SQL Procedure (Automatically):

CREATE PROCEDURE [spCreateAIPrompt]
    @PromptRole nvarchar(20),
    -- 20+ other parameters auto-generated
AS BEGIN
    -- Complete CRUD logic with validation
END

All from ONE schema change. All type-safe. All production-ready.

Quick Start - Watch The Magic

import { initializeConfig, runCodeGen } from '@memberjunction/codegen-lib';

// Initialize configuration
await initializeConfig();

// Generate your entire application stack
await runCodeGen();

// That's it. Seriously.

Your database schema just became:

• ✅ 295+ TypeScript entity classes with full validation
• ✅ Complete Angular UI with smart form controls
• ✅ All SQL stored procedures for every operation
• ✅ GraphQL API with type-safe resolvers
• ✅ Perfect type safety across your entire stack

Core Capabilities

🏗️ Entity Subclass Generation

Generates bullet-proof TypeScript classes from your database schema:

// Auto-generated from your schema
export class AIPromptEntity extends BaseEntity {
  // 30+ properties with perfect types
  PromptRole: 'System' | 'User' | 'Assistant' | 'SystemOrUser';
  
  // AI-powered validation from CHECK constraints
  validate(): ValidationResult {
    return this.validateWithZod(AIPromptSchema);
  }
}

🎨 Angular Component Generation

Creates production-ready Angular forms with intelligent field types:

// Auto-detects relationships and creates search components
<mj-form-field 
    FieldName="CategoryID"
    Type="textbox"           // Smart field type selection
    LinkType="Record"        // Auto-detected relationship
    LinkComponentType="Search" // AI chose search over dropdown
></mj-form-field>

🗃️ SQL Script Generation

Generates optimized database objects with best practices:

-- Auto-generated indexes for performance
CREATE INDEX IDX_AUTO_MJ_FKEY_AIPrompt_CategoryID 
ON [AIPrompt] ([CategoryID]);

-- Complete CRUD procedures with validation
CREATE PROCEDURE [spCreateAIPrompt] 
    @PromptRole nvarchar(20) -- Validated against CHECK constraint
-- Full implementation auto-generated

🌐 GraphQL Schema Generation

Creates type-safe GraphQL APIs from your entities:

type AIPrompt {
  id: ID!
  promptRole: PromptRoleEnum!  # Auto-generated from CHECK constraint
  category: AIPromptCategory   # Auto-resolved relationships
}

enum PromptRoleEnum {
  SYSTEM
  USER
  ASSISTANT
  SYSTEMORUSER
}

🔬 Database Schema Introspection

Reverse-engineers your entire database into metadata:

const schemaInfo = await analyzeSchema(connection);
// Discovers tables, relationships, constraints, indexes
// Feeds AI engine for intelligent code generation

Advanced Features That Blow Minds

🤖 AI-Powered CHECK Constraint Translation

Our AI doesn't just copy constraints - it understands intent:

-- Complex constraint
CHECK ([Status] IN ('Draft', 'Published', 'Archived') 
       AND [PublishedAt] IS NOT NULL WHEN [Status] = 'Published')

Becomes perfect TypeScript:

Status: z.union([z.literal('Draft'), z.literal('Published'), z.literal('Archived')])
  .refine((status, ctx) => {
    if (status === 'Published' && !this.PublishedAt) {
      ctx.addIssue({ code: 'custom', message: 'Published items must have PublishedAt' });
    }
  })

🔄 Real-Time Synchronization

Change your database schema → Everything updates automatically:

1. Flyway migration executes
2. CodeGen detects changes
3. Regenerates affected code
4. Type safety maintained across entire stack
5. Zero manual intervention

🚀 Performance Optimization

• Intelligent caching prevents unnecessary regeneration
• Incremental updates for changed entities only
• Optimized SQL with proper indexing strategies
• Lazy loading for large schema datasets

🔒 Enterprise-Grade Security

• Parameterized queries in all generated SQL
• Input validation at every layer
• SQL injection protection built-in
• Type-safe APIs prevent runtime errors

Configuration

Create a .memberjunctionrc file:

{
  "memberjunction": {
    "database": {
      "server": "localhost",
      "database": "YourDatabase",
      "trustedConnection": true
    },
    "directories": {
      "output": "./generated",
      "entities": "./generated/entities",
      "actions": "./generated/actions",
      "angular": "./generated/angular",
      "sql": "./generated/sql"
    },
    "ai": {
      "enabled": true,
      "provider": "openai"  // Powers constraint translation
    }
  }
}

Real-World Example

Starting with a simple table:

CREATE TABLE [Customer] (
    [ID] uniqueidentifier PRIMARY KEY DEFAULT newsequentialid(),
    [Name] nvarchar(255) NOT NULL,
    [Status] nvarchar(20) CHECK ([Status] IN ('Active', 'Inactive', 'Suspended')),
    [CreatedAt] datetimeoffset DEFAULT getutcdate()
);

One CodeGen run produces:

TypeScript Entity (175 lines)

export class CustomerEntity extends BaseEntity {
    Status: 'Active' | 'Inactive' | 'Suspended';
    // + complete validation, save methods, relationships
}

Angular Component (89 lines)

@Component({
    template: `Complete form with validation and smart controls`
})
export class CustomerDetailsComponent {
    // Ready for production use
}

SQL Procedures (200+ lines)

-- spCreateCustomer, spUpdateCustomer, spDeleteCustomer
-- Complete with validation and error handling

GraphQL Schema (45 lines)

type Customer {
    # Complete type-safe schema
}

Total: 500+ lines of production code from 6 lines of SQL.

API Reference

Core Functions

// Generate everything at once
await runCodeGen();

// Generate specific components
await generateEntitySubClasses(options);
await generateAngularEntityCode(options); 
await generateSQLScripts(options);
await generateGraphQLServerCode(options);

Entity Subclass Generation

import { generateEntitySubClasses } from '@memberjunction/codegen-lib';

const result = await generateEntitySubClasses({
  outputDirectory: './generated/entities',
  generateLoader: true,
  generateCustomEntityClasses: true,
  aiEnhanced: true,           // Enable AI features
  incrementalMode: true,      // Only update changed entities
  validateGenerated: true     // Compile-check generated code
});

Action Subclass Generation

import { generateActionSubClasses } from '@memberjunction/codegen-lib';

const result = await generateActionSubClasses({
  outputDirectory: './generated/actions',
  generateLoader: true
});

GraphQL Server Generation

import { generateGraphQLServerCode } from '@memberjunction/codegen-lib';

await generateGraphQLServerCode({
  outputDirectory: './generated/graphql',
  entities: entityMetadata
});

SQL Code Generation

import { generateSQLScripts } from '@memberjunction/codegen-lib';

await generateSQLScripts({
  outputDirectory: './generated/sql',
  includeStoredProcedures: true,
  includeViews: true
});

Angular Component Generation

import { generateAllAngularEntityCode } from '@memberjunction/codegen-lib';

await generateAllAngularEntityCode({
  outputDirectory: './generated/angular',
  entities: entityMetadata
});

Performance Stats

On a typical MemberJunction database with 150+ tables:

• Entity Generation: 2.3 seconds
• Angular Components: 4.7 seconds
• SQL Procedures: 1.8 seconds
• Total Stack Generation: <10 seconds

For 295 entity classes and thousands of generated files.

Integration with MemberJunction Ecosystem

Works seamlessly with:

• @memberjunction/core - Entity framework
• @memberjunction/ai - AI-powered features
• @memberjunction/angular-explorer - UI framework
• @memberjunction/graphql-dataprovider - API layer
• @memberjunction/sqlserver-dataprovider - Data access

Advanced Features

Custom Templates

You can provide custom templates for code generation:

import { setCustomTemplate } from '@memberjunction/codegen-lib';

setCustomTemplate('entity', myCustomEntityTemplate);

Schema Analysis

import { analyzeSchema } from '@memberjunction/codegen-lib';

const schemaInfo = await analyzeSchema(databaseConnection);
// Work with schema information

Progress Tracking

import { onProgress } from '@memberjunction/codegen-lib';

onProgress((status) => {
  console.log(`Progress: ${status.message} (${status.percentage}%)`);
});

Error Handling

The library provides comprehensive error handling:

try {
  await runCodeGen();
} catch (error) {
  if (error.code === 'CONFIG_NOT_FOUND') {
    // Handle missing configuration
  } else if (error.code === 'DB_CONNECTION_FAILED') {
    // Handle database connection errors
  }
}

Why This Changes Everything

Before MemberJunction CodeGen:

• Weeks of manual entity creation
• Inconsistent validation logic
• Type mismatches between layers
• Manual Angular form creation
• Brittle SQL procedures
• Schema changes break everything

After MemberJunction CodeGen:

• 10 seconds to regenerate entire stack
• Perfect type safety across all layers
• AI-powered intelligent code generation
• Zero manual intervention
• Production-ready from day one

Best Practices

1. Configuration Management - Use environment-specific configuration files
2. Output Organization - Keep generated code in separate directories
3. Version Control - Consider excluding generated files from version control
4. Regular Updates - Regenerate code when metadata changes
5. Custom Extensions - Extend generated classes rather than modifying them

Contributing

When contributing to this package:

1. Test with real schemas - We generate production apps
2. Maintain AI accuracy - Constraint translation must be perfect
3. Performance matters - Large schemas must generate quickly
4. Type safety is sacred - Never compromise type correctness

License

This package is part of the MemberJunction ecosystem and follows the same licensing terms.

Ready to experience the future of application development?

npm install @memberjunction/codegen-lib

Your database schema deserves better than manual code generation. Give it the AI-powered, production-ready, full-stack treatment it deserves.