@cdmbase/wiki-browser 12.0.18-alpha.5

package/lib/templates/content/docs/LLM/backend-service-llm.md

@@ -0,0 +1,3384 @@
+# LLM Template: Complete Backend Service Creation Guide
+
+## Overview
+
+This is a comprehensive template for creating backend services in the adminIde-stack architecture. Follow this exact sequence to create new services with GraphQL, Mongoose, templates, and proper module integration.
+
+## ⚠️ CRITICAL: Naming Conventions and Conflict Prevention
+
+### **Module-Prefixed Naming for Large Projects**
+
+**In large monorepo projects, name conflicts are common and destructive. ALWAYS use module prefixes for ALL GraphQL types, enums, queries, and mutations.**
+
+#### **GraphQL Naming Pattern:**
+
+```graphql
+# ✅ CORRECT - Module prefixed (prevents conflicts)
+type MarketplacePublisher @entity {
+    id: ID! @id
+    # ... fields
+}
+
+type MarketplacePublisherStats @entity(embedded: true) {
+    totalDownloads: Int!
+    # ... fields
+}
+
+enum MarketplacePublisherStatus {
+    ACTIVE
+    INACTIVE
+    VERIFIED
+}
+
+input CreateMarketplacePublisherInput {
+    # ... fields
+}
+
+extend type Query {
+    getMarketplacePublisher(id: ID!): MarketplacePublisher @auth
+    listMarketplacePublishers(filter: MarketplacePublisherFilter): [MarketplacePublisher!]! @auth
+}
+
+extend type Mutation {
+    createMarketplacePublisher(input: CreateMarketplacePublisherInput!): MarketplacePublisher! @auth
+    updateMarketplacePublisher(id: ID!, input: UpdateMarketplacePublisherInput!): MarketplacePublisher! @auth
+}
+
+# ❌ WRONG - No prefix (will conflict with other modules)
+type Publisher @entity {
+    id: ID! @id
+}
+
+enum PublisherStatus {
+    ACTIVE
+}
+
+extend type Query {
+    getPublisher(id: ID!): Publisher @auth  # Conflicts with other Publisher types
+}
+```
+
+#### **Why Module Prefixes Matter:**
+
+1. **Conflict Prevention**: Multiple modules may have `Publisher`, `User`, `Project` types
+2. **GraphQL Schema Merging**: All modules merge into single schema - conflicts break builds
+3. **Generated Type Safety**: TypeScript generation creates clean, non-conflicting interfaces
+4. **API Clarity**: Clear which module/domain the type belongs to
+5. **Maintenance**: Easy to identify type ownership across large teams
+
+#### **Prefix Examples by Module:**
+
+- **Marketplace**: `MarketplacePublisher`, `MarketplaceExtension`, `MarketplaceStats`
+- **Account**: `AccountUser`, `AccountOrganization`, `AccountTeam`
+- **Project**: `ProjectTask`, `ProjectTemplate`, `ProjectStatus`
+- **Extension**: `ExtensionRegistry`, `ExtensionInstalled`, `ExtensionManifest`
+- **Billing**: `BillingPlan`, `BillingInvoice`, `BillingSubscription`
+
+### **Complete Service Creation Workflow**
+
+After defining GraphQL schemas with proper prefixes, follow this exact sequence:
+
+1. **Create GraphQL Schemas** (with module prefixes)
+2. **Create Templates** (Service/Repository interfaces)
+3. **Run Template Generation** (copies to common package)
+4. **Implement Services & Repositories** (using generated interfaces)
+5. **Container Binding** (dependency injection setup)
+6. **Module Integration** (createServiceFunc setup)
+7. **Resolver Implementation** (GraphQL endpoint logic)
+8. **Build & Test** (verify integration)
+
+**This workflow ensures:**
+
+- ✅ Type safety across the entire stack
+- ✅ Proper dependency injection
+- ✅ No naming conflicts
+- ✅ Consistent architecture patterns
+- ✅ Template-driven development (not manual interfaces)
+
+## 📋 Complete Implementation Checklist
+
+### Phase 1: GraphQL Schema Design
+
+**File**: `packages-modules/{module}/server/src/graphql/schemas/{entity}.graphql`
+
+```graphql
+# Main Entity with Database Mapping - ALWAYS USE MODULE PREFIX
+type {ModulePrefix}{EntityName} implements Node @entity {
+    id: ID! @id
+    tenantId: String! @column
+
+    # Object References - USE ObjectId pattern for relationships
+    {relationField}: {ModulePrefix}{RelatedType} @column(overrideType: "ObjectId")
+
+    # String/Primitive Fields
+    {fieldName}: String! @column
+    {optionalField}: String @column
+
+    # Embedded Documents
+    {embeddedField}: {ModulePrefix}{EmbeddedType}! @embedded
+
+    # Status/Enum Fields - MODULE PREFIXED
+    status: {ModulePrefix}{EntityName}Status! @column
+
+    # Audit Fields
+    createdAt: DateTime! @column(overrideType: "Date")
+    updatedAt: DateTime @column(overrideType: "Date")
+    createdBy: UserAccount! @column(overrideType: "ObjectId")
+    updatedBy: UserAccount @column(overrideType: "ObjectId")
+}
+
+# Embedded Types - NO @entity directive, use @entity(embedded: true) - MODULE PREFIXED
+type {ModulePrefix}{EmbeddedTypeName} @entity(embedded: true) {
+    {field}: String! @column
+    {nestedField}: Int @column
+    {nestedObject}: {ModulePrefix}{NestedType} @embedded
+}
+
+# Status Enums - MODULE PREFIXED
+enum {ModulePrefix}{EntityName}Status {
+    ACTIVE
+    INACTIVE
+    PENDING
+    ARCHIVED
+}
+
+# Input Types for GraphQL Operations - MODULE PREFIXED
+input Create{ModulePrefix}{EntityName}Input {
+    {fieldName}: String!
+    {optionalField}: String
+    {embeddedInput}: {ModulePrefix}{EmbeddedTypeInput}
+}
+
+input Update{ModulePrefix}{EntityName}Input {
+    {fieldName}: String
+    {optionalField}: String
+    {embeddedInput}: {ModulePrefix}{EmbeddedTypeInput}
+    status: {ModulePrefix}{EntityName}Status
+}
+
+input {ModulePrefix}{EmbeddedTypeInput} {
+    {field}: String
+    {nestedField}: Int
+}
+
+# Query Extensions - MODULE PREFIXED
+extend type Query {
+    get{ModulePrefix}{EntityName}(id: ID!): {ModulePrefix}{EntityName} @auth
+    list{ModulePrefix}{EntityName}s(tenantId: String, filter: {ModulePrefix}{EntityName}Filter): [{ModulePrefix}{EntityName}!]! @auth
+}
+
+# Mutation Extensions - MODULE PREFIXED
+extend type Mutation {
+    create{ModulePrefix}{EntityName}(input: Create{ModulePrefix}{EntityName}Input!): {ModulePrefix}{EntityName}! @auth
+    update{ModulePrefix}{EntityName}(id: ID!, input: Update{ModulePrefix}{EntityName}Input!): {ModulePrefix}{EntityName}! @auth
+    delete{ModulePrefix}{EntityName}(id: ID!): Boolean! @auth
+}
+```
+
+**Key Points:**
+
+1. **Object References**: Use `@column(overrideType: "ObjectId")` for relationships
+2. **Embedded Types**: Use `@entity(embedded: true)` for nested objects
+3. **Field Mapping**: API uses human-readable IDs, database stores ObjectId references
+4. **Audit Fields**: Always include createdAt, updatedAt, createdBy, updatedBy
+
+### Phase 2: Event System in service.graphql
+
+**File**: `packages-modules/{module}/server/src/graphql/schemas/service.graphql`
+
+```graphql
+# Extension-specific event types (NO @entity directives for events!)
+type {EntityName}CreatedEvent {
+    {entity}Id: String!
+    tenantId: String!
+    createdBy: String!
+    createdAt: String!
+    {fieldName}: String!
+    status: String!
+}
+
+type {EntityName}UpdatedEvent {
+    {entity}Id: String!
+    tenantId: String!
+    updatedBy: String!
+    updatedAt: String!
+    changes: JSON
+    previousStatus: String
+    newStatus: String
+}
+
+type {EntityName}DeletedEvent {
+    {entity}Id: String!
+    tenantId: String!
+    deletedBy: String!
+    deletedAt: String!
+    reason: String
+}
+
+type {EntityName}StatusChangedEvent {
+    {entity}Id: String!
+    tenantId: String!
+    changedBy: String!
+    changedAt: String!
+    fromStatus: String!
+    toStatus: String!
+    reason: String
+}
+```
+
+### Phase 3: Service Template Creation
+
+**File**: `packages-modules/{module}/server/src/templates/services/{EntityName}Service.ts.template`
+
+````typescript
+// from package: {module}-server
+import {
+    I{EntityName}Model,
+    ICreate{EntityName}Input,
+    IUpdate{EntityName}Input,
+    I{EntityName}Filter,
+    I{EntityName}CreatedEvent,
+    I{EntityName}UpdatedEvent,
+    I{EntityName}DeletedEvent,
+} from 'common/server';
+
+/**
+ * Extended input type for creating {entity} with server-side fields
+ */
+export interface ICreate{EntityName}ServerInput extends ICreate{EntityName}Input {
+    tenantId: string;
+    createdBy: string; // User ObjectId as string
+}
+
+/**
+ * Extended input type for updating {entity} with server-side fields
+ */
+export interface IUpdate{EntityName}ServerInput extends IUpdate{EntityName}Input {
+    updatedBy: string; // User ObjectId as string
+}
+
+/**
+ * Service interface for managing {entity} entities
+ * IMPORTANT: All service methods that return domain entities MUST use AsDomainType<IEntityModel>
+ * This ensures proper type compatibility between MongoDB models and GraphQL domain types
+ */
+export interface I{EntityName}Service {
+    /**
+     * Create a new {entity}
+     */
+    create{EntityName}(input: ICreate{EntityName}ServerInput): Promise<AsDomainType<I{EntityName}Model>>;
+
+    /**
+     * Update an existing {entity}
+     */
+    update{EntityName}(id: string, input: IUpdate{EntityName}ServerInput): Promise<AsDomainType<I{EntityName}Model>>;
+
+    /**
+     * Get a {entity} by ID
+     */
+    get{EntityName}(id: string, tenantId: string): Promise<AsDomainType<I{EntityName}Model> | null>;
+
+    /**
+     * List {entity} entities with filtering
+     */
+    list{EntityName}s(filter: I{EntityName}Filter): Promise<AsDomainType<I{EntityName}Model>[]>;
+
+    /**
+     * Delete a {entity}
+     */
+    delete{EntityName}(id: string, tenantId: string, deletedBy: string): Promise<boolean>;
+
+    /**
+     * Update {entity} status
+     */
+    update{EntityName}Status(
+        id: string,
+        tenantId: string,
+        status: string,
+        changedBy: string,
+    ): Promise<AsDomainType<I{EntityName}Model>>;
+
+    /**
+     * Check if {entity} exists
+     */
+    {entity}Exists(id: string, tenantId: string): Promise<boolean>;
+}
+
+## 🔄 Critical Service Return Type Pattern
+
+**MANDATORY**: All service methods returning domain entities MUST use `AsDomainType<IEntityModel>`
+
+### Why AsDomainType is Required
+
+```typescript
+// ❌ WRONG - Direct model return
+Promise<IEntityModel>
+
+// ✅ CORRECT - AsDomainType wrapper
+Promise<AsDomainType<IEntityModel>>
+Promise<AsDomainType<IEntityModel> | null>
+Promise<AsDomainType<IEntityModel>[]>
+````
+
+### Service Implementation Pattern
+
+```typescript
+// In service implementation - ALWAYS cast the return
+public async create{EntityName}(input: ICreate{EntityName}Input): Promise<AsDomainType<I{EntityName}Model>> {
+    const result = await this.repository.create(input);
+
+    // CRITICAL: Cast repository result via unknown for type compatibility
+    return result as unknown as AsDomainType<I{EntityName}Model>;
+}
+
+// For nullable returns
+public async get{EntityName}(id: string): Promise<AsDomainType<I{EntityName}Model> | null> {
+    const result = await this.repository.findById(id);
+
+    // Handle null case explicitly
+    return result ? (result as unknown as AsDomainType<I{EntityName}Model>) : null;
+}
+
+// For arrays
+public async list{EntityName}s(filter: IFilter): Promise<AsDomainType<I{EntityName}Model>[]> {
+    const results = await this.repository.findMany(filter);
+
+    // Cast entire array
+    return results as unknown as AsDomainType<I{EntityName}Model>[];
+}
+```
+
+### Import Requirements
+
+```typescript
+import { AsDomainType } from 'common/server';
+```
+
+**Note**: AsDomainType bridges the gap between MongoDB models (with `_id`) and GraphQL domain types (with `id`). The type casting via `unknown` is necessary for TypeScript compatibility.
+
+/\*\*
+
+- This file augments the ServerContext interface from the central apollo-context.
+- Through declaration merging, the {entity}Service will be added to the ServerContext.
+  \*/
+  declare module '../apollo-context' {
+  export interface ServerContext {
+  {entity}Service: I{EntityName}Service;
+  }
+  }
+
+````
+
+### Phase 4: Repository Template Creation
+
+**File**: `packages-modules/{module}/server/src/templates/repositories/{EntityName}Repository.ts.template`
+
+```typescript
+// from package: {module}-server
+import { I{EntityName}Model, I{EntityName}Filter } from 'common/server';
+import { ICreate{EntityName}ServerInput, IUpdate{EntityName}ServerInput } from '../services/{EntityName}Service';
+
+/**
+ * Repository interface for {EntityName} data access
+ */
+export interface I{EntityName}Repository {
+    /**
+     * Create a new {entity}
+     */
+    create(input: ICreate{EntityName}ServerInput): Promise<I{EntityName}Model>;
+
+    /**
+     * Update an existing {entity}
+     */
+    update(id: string, input: IUpdate{EntityName}ServerInput): Promise<I{EntityName}Model>;
+
+    /**
+     * Find a {entity} by ID and tenant
+     */
+    findById(id: string, tenantId: string): Promise<I{EntityName}Model | null>;
+
+    /**
+     * Find multiple {entity} entities with filtering
+     */
+    find(filter: I{EntityName}Filter): Promise<I{EntityName}Model[]>;
+
+    /**
+     * Delete a {entity}
+     */
+    delete(id: string, tenantId: string): Promise<boolean>;
+
+    /**
+     * Check if {entity} exists
+     */
+    exists(id: string, tenantId: string): Promise<boolean>;
+
+    /**
+     * Update {entity} status
+     */
+    updateStatus(id: string, tenantId: string, status: string, updatedBy: string): Promise<I{EntityName}Model>;
+
+    /**
+     * Get {entity} count with optional filtering
+     */
+    count(filter?: Partial<I{EntityName}Filter>): Promise<number>;
+}
+````
+
+### Phase 5: Constants Template Update
+
+**File**: `packages-modules/{module}/server/src/templates/constants/DB_COLL_NAMES.ts.template`
+
+```typescript
+export const DB_COLL_NAMES = {
+    // ... existing collections
+    {EntityName}: '{entityName}s',
+    // Add other related collections if needed
+} as const;
+
+export const SERVER_TYPES = {
+    // ... existing types
+    I{EntityName}Service: Symbol.for('I{EntityName}Service'),
+    I{EntityName}Repository: Symbol.for('I{EntityName}Repository'),
+} as const;
+```
+
+### Phase 6: Run Template Generation
+
+```bash
+# CRITICAL: Navigate to ROOT of the project (not module directory)
+cd /path/to/your/project-root
+
+# CRITICAL: Always run these commands in sequence from PROJECT ROOT
+# 1. Regenerate templates (copies to common package but may remove codegen files)
+yarn regenerateGraphql
+
+# 2. IMMEDIATELY generate GraphQL types (restores codegen files)
+yarn generateGraphql
+```
+
+**⚠️ CRITICAL**:
+
+- Both commands MUST be run from the PROJECT ROOT, not the module directory
+- Always run `yarn regenerateGraphql && yarn generateGraphql` in sequence
+- The regenerateGraphql command copies templates to the common package but can remove codegen files
+- The generateGraphql command must be run immediately after to regenerate TypeScript types
+
+### Phase 7: Mongoose Model Creation
+
+**File**: `packages-modules/{module}/server/src/store/models/{entity-name}-model.ts`
+
+```typescript
+import { Schema, Types } from 'mongoose';
+import type { I{EntityName}Model, I{EmbeddedType}Model, {EntityName}Status } from 'common/server';
+import { DB_COLL_NAMES } from 'common/server';
+
+// Embedded Schema (if applicable)
+const {EmbeddedType}Schema = new Schema<I{EmbeddedType}Model>({
+    {field}: {
+        type: String,
+        required: true,
+    },
+    {nestedField}: {
+        type: Number,
+        default: 0,
+    },
+}, { _id: false }); // No _id for embedded documents
+
+// Main Entity Schema
+const {EntityName}Schema = new Schema<I{EntityName}Model>({
+    tenantId: {
+        type: String,
+        required: true,
+        index: true,
+    },
+    {relationField}: {
+        type: Schema.Types.ObjectId,
+        ref: DB_COLL_NAMES.{RelatedEntity}, // Reference to related collection
+        required: true,
+        index: true,
+    },
+    {fieldName}: {
+        type: String,
+        required: true,
+        index: true,
+    },
+    {optionalField}: {
+        type: String,
+        index: true,
+    },
+    {embeddedField}: {
+        type: {EmbeddedType}Schema,
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values({EntityName}Status), // Use enum from codegen
+        default: {EntityName}Status.Active,
+        index: true,
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now,
+        index: true,
+    },
+    updatedAt: {
+        type: Date,
+        index: true,
+    },
+    createdBy: {
+        type: Schema.Types.ObjectId,
+        ref: DB_COLL_NAMES.UserAccount,
+        required: true,
+        index: true,
+    },
+    updatedBy: {
+        type: Schema.Types.ObjectId,
+        ref: DB_COLL_NAMES.UserAccount,
+        index: true,
+    },
+}, {
+    timestamps: true, // Automatically manage createdAt/updatedAt
+    collection: DB_COLL_NAMES.{EntityName},
+});
+
+// Virtual for id field
+{EntityName}Schema.virtual('id').get(function() {
+    return this._id?.toHexString();
+});
+
+// Ensure virtual fields are serialized
+{EntityName}Schema.set('toJSON', {
+    virtuals: true,
+    transform: (doc, ret) => {
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+    },
+});
+
+{EntityName}Schema.set('toObject', { virtuals: true });
+
+// Indexes for common queries
+{EntityName}Schema.index({ tenantId: 1, status: 1 });
+{EntityName}Schema.index({ tenantId: 1, {relationField}: 1 });
+{EntityName}Schema.index({ createdAt: -1 });
+
+// Export model function
+export const {EntityName}ModelFunc = (conn: any) =>
+    conn.model(DB_COLL_NAMES.{EntityName}, {EntityName}Schema);
+```
+
+### Phase 8: Repository Implementation
+
+**File**: `packages-modules/{module}/server/src/store/repositories/{entity-name}-repository.ts`
+
+```typescript
+import { injectable } from 'inversify';
+import { Connection } from 'mongoose';
+import { BaseRepository } from '@cdm-logger/server';
+import type { I{EntityName}Model, I{EntityName}Filter } from 'common/server';
+import type { I{EntityName}Repository, ICreate{EntityName}ServerInput, IUpdate{EntityName}ServerInput } from 'common/server';
+import { {EntityName}ModelFunc } from '../models';
+
+@injectable()
+export class {EntityName}Repository extends BaseRepository<I{EntityName}Model> implements I{EntityName}Repository {
+    constructor(connection: Connection) {
+        const {EntityName}Model = {EntityName}ModelFunc(connection);
+        super({EntityName}Model);
+    }
+
+    async create(input: ICreate{EntityName}ServerInput): Promise<I{EntityName}Model> {
+        const {entity}Data = {
+            ...input,
+            createdAt: new Date(),
+        };
+        return await this.create(entityData);
+    }
+
+    async update(id: string, input: IUpdate{EntityName}ServerInput): Promise<I{EntityName}Model> {
+        const updateData = {
+            ...input,
+            updatedAt: new Date(),
+        };
+
+        const updated = await this.update(
+            { _id: id, tenantId: input.tenantId },
+            updateData,
+            { new: true }
+        );
+
+        if (!updated) {
+            throw new Error(`{EntityName} not found: ${id}`);
+        }
+
+        return updated;
+    }
+
+    async findById(id: string, tenantId: string): Promise<I{EntityName}Model | null> {
+        return await this.get({ _id: id, tenantId });
+    }
+
+    async find(filter: I{EntityName}Filter): Promise<I{EntityName}Model[]> {
+        const conditions: any = {};
+
+        if (filter.tenantId) {
+            conditions.tenantId = filter.tenantId;
+        }
+
+        if (filter.status?.length) {
+            conditions.status = { $in: filter.status };
+        }
+
+        if (filter.{fieldName}) {
+            conditions.{fieldName} = new RegExp(filter.{fieldName}, 'i');
+        }
+
+        if (filter.createdBy) {
+            conditions.createdBy = filter.createdBy;
+        }
+
+        return await this.getAll({
+            conditions,
+            sort: { createdAt: -1 },
+        });
+    }
+
+    async delete(id: string, tenantId: string): Promise<boolean> {
+        const result = await this.delete({ _id: id, tenantId });
+        return result.deletedCount > 0;
+    }
+
+    async exists(id: string, tenantId: string): Promise<boolean> {
+        const count = await this.count({ _id: id, tenantId });
+        return count > 0;
+    }
+
+    async updateStatus(
+        id: string,
+        tenantId: string,
+        status: string,
+        updatedBy: string
+    ): Promise<I{EntityName}Model> {
+        return await this.update(id, {
+            status,
+            updatedBy,
+            tenantId,
+        });
+    }
+
+    async count(filter?: Partial<I{EntityName}Filter>): Promise<number> {
+        const conditions: any = {};
+
+        if (filter?.tenantId) {
+            conditions.tenantId = filter.tenantId;
+        }
+
+        if (filter?.status?.length) {
+            conditions.status = { $in: filter.status };
+        }
+
+        return await this.count(conditions);
+    }
+}
+```
+
+### Phase 9: Service Implementation
+
+**File**: `packages-modules/{module}/server/src/services/{entity-name}-service.ts`
+
+```typescript
+import { injectable, inject } from 'inversify';
+import { Emitter } from '@common-stack/utils';
+import { BaseService } from '@cdm-logger/server';
+import { SERVER_TYPES } from 'common/server';
+import type {
+    I{EntityName}Model,
+    I{EntityName}Service,
+    I{EntityName}Repository,
+    I{EntityName}Filter,
+    I{EntityName}CreatedEvent,
+    I{EntityName}UpdatedEvent,
+    I{EntityName}DeletedEvent,
+    AsDomainType,
+} from 'common/server';
+import type { ICreate{EntityName}ServerInput, IUpdate{EntityName}ServerInput } from 'common/server';
+
+@injectable()
+export class {EntityName}Service extends BaseService<I{EntityName}Model> implements I{EntityName}Service {
+    // Event emitters for broadcasting operations
+    protected readonly on{EntityName}Created = new Emitter<I{EntityName}CreatedEvent>();
+    protected readonly on{EntityName}Updated = new Emitter<I{EntityName}UpdatedEvent>();
+    protected readonly on{EntityName}Deleted = new Emitter<I{EntityName}DeletedEvent>();
+    protected readonly on{EntityName}StatusChanged = new Emitter<I{EntityName}StatusChangedEvent>();
+
+    constructor(
+        @inject(SERVER_TYPES.I{EntityName}Repository)
+        private {entity}Repository: I{EntityName}Repository,
+    ) {
+        super();
+    }
+
+    // Event getters for external access
+    public get {entity}Created() {
+        return this.on{EntityName}Created.event;
+    }
+
+    public get {entity}Updated() {
+        return this.on{EntityName}Updated.event;
+    }
+
+    public get {entity}Deleted() {
+        return this.on{EntityName}Deleted.event;
+    }
+
+    public get {entity}StatusChanged() {
+        return this.on{EntityName}StatusChanged.event;
+    }
+
+    async create{EntityName}(input: ICreate{EntityName}ServerInput): Promise<I{EntityName}Model> {
+        // Business logic validation
+        const existing = await this.{entity}Repository.exists(
+            input.{fieldName}, // or relevant unique field
+            input.tenantId
+        );
+
+        if (existing) {
+            throw new Error(`{EntityName} with {fieldName} '${input.{fieldName}}' already exists`);
+        }
+
+        // Create the entity
+        const {entity} = await this.{entity}Repository.create(input);
+
+        // Fire event
+        const event: I{EntityName}CreatedEvent = {
+            {entity}Id: {entity}.id!,
+            tenantId: {entity}.tenantId,
+            createdBy: input.createdBy,
+            createdAt: {entity}.createdAt.toISOString(),
+            {fieldName}: {entity}.{fieldName},
+            status: {entity}.status,
+        };
+        this.on{EntityName}Created.fire(event);
+
+        return {entity};
+    }
+
+    async update{EntityName}(id: string, input: IUpdate{EntityName}ServerInput): Promise<I{EntityName}Model> {
+        // Get current state for change detection
+        const current = await this.{entity}Repository.findById(id, input.tenantId);
+        if (!current) {
+            throw new Error(`{EntityName} not found: ${id}`);
+        }
+
+        // Update the entity
+        const updated = await this.{entity}Repository.update(id, input);
+
+        // Fire event
+        const event: I{EntityName}UpdatedEvent = {
+            {entity}Id: updated.id!,
+            tenantId: updated.tenantId,
+            updatedBy: input.updatedBy,
+            updatedAt: updated.updatedAt!.toISOString(),
+            changes: this.getChanges(current, updated),
+            previousStatus: current.status,
+            newStatus: updated.status,
+        };
+        this.on{EntityName}Updated.fire(event);
+
+        return updated;
+    }
+
+    async get{EntityName}(id: string, tenantId: string): Promise<I{EntityName}Model | null> {
+        return await this.{entity}Repository.findById(id, tenantId);
+    }
+
+    async list{EntityName}s(filter: I{EntityName}Filter): Promise<I{EntityName}Model[]> {
+        return await this.{entity}Repository.find(filter);
+    }
+
+    async delete{EntityName}(id: string, tenantId: string, deletedBy: string): Promise<boolean> {
+        // Get entity before deletion for event
+        const {entity} = await this.{entity}Repository.findById(id, tenantId);
+        if (!{entity}) {
+            throw new Error(`{EntityName} not found: ${id}`);
+        }
+
+        // Delete the entity
+        const deleted = await this.{entity}Repository.delete(id, tenantId);
+
+        if (deleted) {
+            // Fire event
+            const event: I{EntityName}DeletedEvent = {
+                {entity}Id: id,
+                tenantId,
+                deletedBy,
+                deletedAt: new Date().toISOString(),
+                reason: 'Manual deletion',
+            };
+            this.on{EntityName}Deleted.fire(event);
+        }
+
+        return deleted;
+    }
+
+    async update{EntityName}Status(
+        id: string,
+        tenantId: string,
+        status: string,
+        changedBy: string,
+    ): Promise<I{EntityName}Model> {
+        const current = await this.{entity}Repository.findById(id, tenantId);
+        if (!current) {
+            throw new Error(`{EntityName} not found: ${id}`);
+        }
+
+        const previousStatus = current.status;
+        const updated = await this.{entity}Repository.updateStatus(id, tenantId, status, changedBy);
+
+        // Fire status change event
+        const event: I{EntityName}StatusChangedEvent = {
+            {entity}Id: id,
+            tenantId,
+            changedBy,
+            changedAt: new Date().toISOString(),
+            fromStatus: previousStatus,
+            toStatus: status,
+            reason: 'Status update',
+        };
+        this.on{EntityName}StatusChanged.fire(event);
+
+        return updated;
+    }
+
+    async {entity}Exists(id: string, tenantId: string): Promise<boolean> {
+        return await this.{entity}Repository.exists(id, tenantId);
+    }
+
+    // Helper method to detect changes
+    private getChanges(before: I{EntityName}Model, after: I{EntityName}Model): any {
+        const changes: any = {};
+
+        if (before.{fieldName} !== after.{fieldName}) {
+            changes.{fieldName} = { from: before.{fieldName}, to: after.{fieldName} };
+        }
+
+        if (before.status !== after.status) {
+            changes.status = { from: before.status, to: after.status };
+        }
+
+        return changes;
+    }
+
+    // Cleanup method
+    dispose(): void {
+        this.on{EntityName}Created.dispose();
+        this.on{EntityName}Updated.dispose();
+        this.on{EntityName}Deleted.dispose();
+        this.on{EntityName}StatusChanged.dispose();
+    }
+}
+```
+
+### Phase 10: Moleculer Service Extension (Optional)
+
+**File**: `packages-modules/{module}/server/src/services/{entity-name}-service-ext.ts`
+
+```typescript
+import { injectable, inject } from 'inversify';
+import { Moleculer } from '@common-stack/server-core';
+import { {EntityName}Service } from './{entity-name}-service';
+import { MoleculerServiceName, {EntityName}ServiceAction } from '../constants';
+import type { I{EntityName}CreatedEvent, I{EntityName}UpdatedEvent, I{EntityName}DeletedEvent } from 'common/server';
+
+@injectable()
+export class {EntityName}ServiceExt extends {EntityName}Service {
+    private broker: any;
+
+    constructor(
+        @inject('Environment') environment: any,
+        ...args: any[]
+    ) {
+        super(...args);
+        this.broker = environment.broker;
+        this.setupEventListeners();
+    }
+
+    private setupEventListeners(): void {
+        // Broadcast created event
+        this.{entity}Created((event: I{EntityName}CreatedEvent) => {
+            this.broker.broadcast({EntityName}ServiceAction.On{EntityName}Created, { event }, [
+                MoleculerServiceName.NotificationService,
+                MoleculerServiceName.AuditService,
+            ]);
+        });
+
+        // Broadcast updated event
+        this.{entity}Updated((event: I{EntityName}UpdatedEvent) => {
+            this.broker.broadcast({EntityName}ServiceAction.On{EntityName}Updated, { event }, [
+                MoleculerServiceName.NotificationService,
+                MoleculerServiceName.AuditService,
+            ]);
+        });
+
+        // Broadcast deleted event
+        this.{entity}Deleted((event: I{EntityName}DeletedEvent) => {
+            this.broker.broadcast({EntityName}ServiceAction.On{EntityName}Deleted, { event }, [
+                MoleculerServiceName.NotificationService,
+                MoleculerServiceName.AuditService,
+            ]);
+        });
+    }
+}
+```
+
+### Phase 11: DataLoader Implementation (for Object Resolution)
+
+**Files**:
+
+- `packages-modules/{module}/server/src/dataloaders/{entity}-data-loader.ts`
+- `packages-modules/{module}/server/src/dataloaders/index.ts`
+- `packages-modules/{module}/server/src/templates/services/{EntityName}DataLoader.ts.template`
+
+```typescript
+// DataLoader Implementation
+import { I{EntityName}, I{EntityName}Service, SERVER_TYPES, IBaseService, AsDomainType } from 'common/server';
+import { injectable, inject } from 'inversify';
+import { BulkDataLoader2 } from '@common-stack/store-mongo';
+
+@injectable()
+export class {EntityName}DataLoader extends BulkDataLoader2<AsDomainType<I{EntityName}>> {
+    constructor(
+        @inject(SERVER_TYPES.I{EntityName}Service)
+        {entity}Service: I{EntityName}Service,
+    ) {
+        super({entity}Service as unknown as IBaseService<AsDomainType<I{EntityName}>>);
+    }
+}
+```
+
+**DataLoader Index**:
+
+```typescript
+// File: packages-modules/{module}/server/src/dataloaders/index.ts
+export { {EntityName}DataLoader } from './{entity}-data-loader';
+```
+
+**Template File**:
+
+```typescript
+// File: packages-modules/{module}/server/src/templates/services/{EntityName}DataLoader.ts.template
+import { I{EntityName}, IDataLoader } from 'common/server';
+export type I{EntityName}DataLoader = IDataLoader<I{EntityName}>;
+```
+
+### Phase 12: GraphQL Resolver Implementation
+
+**File**: `packages-modules/{module}/server/src/graphql/resolvers/{entity-name}-resolver.ts`
+
+````typescript
+import { IResolvers } from '@graphql-tools/utils';
+import { IResolverOptions } from '@common-stack/server-core';
+import type {
+    I{EntityName}Model,
+    ICreate{EntityName}Input,
+    IUpdate{EntityName}Input,
+    ServerContext
+} from 'common/server';
+
+// Define context interface for this resolver
+interface I{EntityName}Context extends ServerContext {
+    {entity}Service: any; // Will be injected via createServiceFunc
+    {entity}DataLoader: any; // DataLoader for resolving object references
+    userContext: {
+        tenantId: string;
+        userId: string;
+        accountId: string;
+        emailId: string;
+        organization?: {
+            id: string;
+            name: string;
+        };
+    };
+}
+
+export const resolvers: (options: IResolverOptions) => IResolvers = (options) => ({
+    // Field resolvers for nested data relationships
+    {EntityName}: {
+        // Resolve object references using DataLoaders
+        {relationField}: async (
+            parent: I{EntityName}Model,
+            _: any,
+            { {relatedEntity}DataLoader }: I{EntityName}Context,
+        ) => {
+            // Check if the relation field exists and is not null before calling dataloader
+            if (!parent.{relationField} || parent.{relationField} === null || parent.{relationField} === undefined) {
+                return null;
+            }
+            const relationId = String(parent.{relationField});
+            return {relatedEntity}DataLoader.load(relationId);
+        },
+
+        // Resolve computed fields or complex transformations
+        displayName: (parent: I{EntityName}Model) => {
+            return `${parent.{fieldName}} (${parent.status})`;
+        },
+
+        // Resolve configuration or settings URIs (following team-resolver pattern)
+        settingsUri: (params: I{EntityName}Model, args: any, { userContext }: I{EntityName}Context) => {
+            // Create a resource URI for configuration management
+            return createStandardResourceUri(
+                ConfigCollectionName.{EntityName}s, // Collection name
+                params.id,
+                params.{relationField} as unknown as string, // Parent relation
+                {
+                    tenantId: userContext.tenantId,
+                    fragment: ConfigFragmentName.Settings,
+                },
+            );
+        },
+    },
+
+    Query: {
+        get{EntityName}: async (
+            _: any,
+            { id }: { id: string },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName} | null> => {
+            options.logger.trace('(Query.get{EntityName}) id [%j]', id);
+
+            if (!userContext?.tenantId) {
+                throw new Error('Authentication required');
+            }
+
+            // Cast service result to GraphQL interface type
+            // Field resolvers will handle ObjectId → object transformations via DataLoaders
+            const result = await {entity}Service.get{EntityName}(id, userContext.tenantId);
+            return result as unknown as I{EntityName} | null;
+        },
+
+        list{EntityName}s: async (
+            _: any,
+            { filter }: { filter?: any },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}[]> => {
+            options.logger.trace('(Query.list{EntityName}s) filter [%j]', filter);
+
+            if (!userContext?.tenantId) {
+                throw new Error('Authentication required');
+            }
+
+            const searchFilter = {
+                tenantId: userContext.tenantId,
+                ...filter,
+            };
+
+            // Cast service result to GraphQL interface type
+            // Field resolvers will handle ObjectId → object transformations via DataLoaders
+            const result = await {entity}Service.list{EntityName}s(searchFilter);
+            return result as unknown as I{EntityName}[];
+        },
+
+        // User-specific queries
+        getUser{EntityName}s: async (
+            _: any,
+            args: any,
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}Model[]> => {
+            options.logger.trace('(Query.getUser{EntityName}s) args [%j]', args);
+
+            if (!userContext) {
+                return [];
+            }
+
+            return await {entity}Service.list{EntityName}s({
+                tenantId: userContext.tenantId,
+                createdBy: userContext.accountId,
+            });
+        },
+
+        // Organization/tenant-wide queries with permissions
+        getOrganization{EntityName}s: async (
+            _: any,
+            { orgName }: { orgName?: string },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}Model[]> => {
+            options.logger.trace('(Query.getOrganization{EntityName}s) orgName [%j]', orgName);
+
+            if (!userContext) {
+                return [];
+            }
+
+            const { permissions, accountId } = userContext;
+            let fullAccess = false;
+
+            // Check permissions for viewing organization-wide data
+            if (permissions?.organization?.{entity}s?.viewOthers === PermissionType.Allow) {
+                fullAccess = true;
+            }
+
+            return await {entity}Service.getOrganization{EntityName}s(
+                orgName || userContext?.organization?.name,
+                accountId,
+                fullAccess,
+            );
+        },
+    },
+
+    Mutation: {
+        create{EntityName}: async (
+            _: any,
+            { input }: { input: ICreate{EntityName}Input },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}> => {
+            options.logger.trace('(Mutation.create{EntityName}) input [%j]', input);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            const serverInput = {
+                ...input,
+                tenantId: userContext.tenantId,
+                createdBy: userContext.userId,
+            };
+
+            try {
+                const result = await {entity}Service.create{EntityName}(serverInput);
+                options.logger.trace('(Mutation.create{EntityName}) result [%j]', result);
+                // Cast service result to GraphQL interface type
+                return result as unknown as I{EntityName};
+            } catch (error) {
+                options.logger.error('Error creating {entity}:', error);
+                throw error;
+            }
+        },
+
+        update{EntityName}: async (
+            _: any,
+            { id, input }: { id: string; input: IUpdate{EntityName}Input },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}> => {
+            options.logger.trace('(Mutation.update{EntityName}) args [%j, %j]', id, input);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            const serverInput = {
+                ...input,
+                tenantId: userContext.tenantId,
+                updatedBy: userContext.userId,
+            };
+
+            try {
+                const result = await {entity}Service.update{EntityName}(id, serverInput);
+                options.logger.trace('(Mutation.update{EntityName}) result [%j]', result);
+                // Cast service result to GraphQL interface type
+                return result as unknown as I{EntityName};
+            } catch (error) {
+                options.logger.error('Error updating {entity}:', error);
+                throw error;
+            }
+        },
+
+        delete{EntityName}: async (
+            _: any,
+            { id }: { id: string },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<boolean> => {
+            options.logger.trace('(Mutation.delete{EntityName}) id [%j]', id);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            try {
+                const result = await {entity}Service.delete{EntityName}(
+                    id,
+                    userContext.tenantId,
+                    userContext.userId
+                );
+                options.logger.trace('(Mutation.delete{EntityName}) result [%j]', result);
+                return result;
+            } catch (error) {
+                options.logger.error('Error deleting {entity}:', error);
+                throw error;
+            }
+        },
+
+        // Status update mutations
+        update{EntityName}Status: async (
+            _: any,
+            { id, status }: { id: string; status: string },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}Model> => {
+            options.logger.trace('(Mutation.update{EntityName}Status) args [%j, %j]', id, status);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            try {
+                const result = await {entity}Service.update{EntityName}Status(
+                    id,
+                    userContext.tenantId,
+                    status,
+                    userContext.userId,
+                );
+                return result;
+            } catch (error) {
+                options.logger.error('Error updating {entity} status:', error);
+                throw error;
+            }
+        },
+
+        // Complex business logic operations (like extension installation)
+        install{EntityName}: async (
+            _: any,
+            { {entity}Id }: { {entity}Id: string },
+            { {entity}Service, registryService, userContext }: I{EntityName}Context,
+        ): Promise<I{EntityName}Model> => {
+            options.logger.trace('(Mutation.install{EntityName}) {entity}Id [%j]', {entity}Id);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            try {
+                // First check if the entity exists in registry
+                const registryEntity = await registryService.find{EntityName}({entity}Id);
+                if (!registryEntity) {
+                    throw new Error(`{EntityName} ${{entity}Id} not found in registry`);
+                }
+
+                // Check if already installed
+                const existingInstallation = await {entity}Service.get{EntityName}(
+                    userContext.tenantId,
+                    {entity}Id
+                );
+
+                if (existingInstallation) {
+                    throw new Error(`{EntityName} ${{entity}Id} is already installed`);
+                }
+
+                // Perform installation with proper input mapping
+                const installInput = {
+                    tenantId: userContext.tenantId,
+                    registryRef: registryEntity._id,
+                    {entity}Id,
+                    installedVersion: registryEntity.version,
+                    installedBy: userContext.userId,
+                };
+
+                const result = await {entity}Service.install{EntityName}(installInput);
+                options.logger.trace('(Mutation.install{EntityName}) result [%j]', result);
+                return result;
+            } catch (error) {
+                options.logger.error('Error installing {entity}:', error);
+                throw error;
+            }
+        },
+
+        uninstall{EntityName}: async (
+            _: any,
+            { {entity}Id }: { {entity}Id: string },
+            { {entity}Service, userContext }: I{EntityName}Context,
+        ): Promise<boolean> => {
+            options.logger.trace('(Mutation.uninstall{EntityName}) {entity}Id [%j]', {entity}Id);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            try {
+                const result = await {entity}Service.uninstall{EntityName}(
+                    userContext.tenantId,
+                    {entity}Id,
+                    userContext.userId
+                );
+
+                if (!result) {
+                    throw new Error(`{EntityName} ${{entity}Id} was not installed`);
+                }
+
+                options.logger.trace('(Mutation.uninstall{EntityName}) result [%j]', result);
+                return result;
+            } catch (error) {
+                options.logger.error('Error uninstalling {entity}:', error);
+                throw error;
+            }
+        },
+    },
+});
+# Key Points for GraphQL Resolvers:**
+
+1. **Use IResolverOptions Pattern**: Follow the `(options: IResolverOptions) => IResolvers` pattern
+2. **Logging**: Use `options.logger.trace()` for request/response logging
+3. **Context Typing**: Define specific context interfaces for type safety
+4. **Error Handling**: Wrap mutations in try-catch with proper error logging
+5. **Authentication**: Always check `userContext` for authentication
+6. **DataLoader Integration**: Use DataLoaders for nested field resolution to prevent N+1 queries
+7. **Permission Checks**: Implement proper authorization logic
+8. **Batch Operations**: Support batch operations where appropriate
+
+### Phase 13: Resolver Index and Integration
+
+**File**: `packages-modules/{module}/server/src/graphql/resolvers/index.ts`
+
+The resolver index file combines all individual resolver files into a single export array. Each resolver file exports a `resolver` function that takes `pubsub` and `logger` parameters.
+
+#### **Individual Resolver File Pattern:**
+```typescript
+// File: {entity-name}-resolver.ts
+import { PubSub } from 'graphql-subscriptions';
+import { CdmLogger } from '@cdm-logger/core';
+import { IResolvers } from 'common/server';
+
+export const resolver = (pubsub: PubSub, logger?: CdmLogger.ILogger): IResolvers => ({
+    // Field resolvers with DataLoaders
+    {EntityName}: {
+        {relationField}: (root, args, { {entity}DataLoader }) => {
+            if (!root.{relationField}) return null;
+            return {entity}DataLoader.load(String(root.{relationField}));
+        },
+    },
+
+    Query: {
+        get{EntityName}: async (_, { id }, { {entity}Service, userContext }) => {
+            const result = await {entity}Service.get{EntityName}(id, userContext.tenantId);
+            return result as unknown as I{EntityName}; // Type casting for DataLoader compatibility
+        },
+    },
+
+    Mutation: {
+        create{EntityName}: async (_, { input }, { {entity}Service, userContext }) => {
+            const result = await {entity}Service.create{EntityName}({
+                ...input,
+                tenantId: userContext.tenantId,
+                createdBy: userContext.accountId,
+            });
+            return result as unknown as I{EntityName}; // Type casting for DataLoader compatibility
+        },
+    },
+});
+````
+
+#### **Index File Combination Pattern:**
+
+```typescript
+// File: packages-modules/{module}/server/src/graphql/resolvers/index.ts
+import { resolver as registryResolver } from './registry-extension-resolver';
+import { resolver as installedExtensionResolver } from './installed-extension-resolver';
+import { resolver as {entity}Resolver } from './{entity-name}-resolver';
+
+// Export array of resolver functions
+export const resolvers = [
+    registryResolver,
+    installedExtensionResolver,
+    {entity}Resolver,
+];
+```
+
+#### **Alternative IResolverOptions Pattern:**
+
+For resolvers following the newer IResolverOptions pattern (like team-resolver), use this approach:
+
+```typescript
+// Individual resolver file
+export const resolvers: (options: IResolverOptions) => IResolvers = (options) => ({
+    // ... resolver implementation with options.logger
+});
+
+// Index file
+import { merge } from 'lodash-es';
+import { resolvers as {entity}Resolvers } from './{entity-name}-resolver';
+import { IResolverOptions } from '@common-stack/server-core';
+
+export const resolvers = (options: IResolverOptions) =>
+    merge(
+        {entity}Resolvers(options),
+        // Add other resolver functions here
+    );
+```
+
+#### **Key Integration Points:**
+
+1. **Function Signature**: Each resolver exports a `resolver` function taking `(pubsub, logger?)` parameters
+2. **Array Export**: Index combines resolvers into an array for GraphQL schema execution
+3. **Naming Convention**: Use `{entity-name}-resolver.ts` for individual files (singular)
+4. **Import Aliasing**: Use `resolver as {entity}Resolver` for clarity in index
+5. **Type Casting**: Always cast service results with `as unknown as I{EntityName}` for DataLoader compatibility
+6. **Context Usage**: Use proper destructuring for `{ userContext, {entity}Service, {entity}DataLoader }`
+
+**File**: `packages-modules/{module}/server/src/graphql/schemas/index.ts`
+
+```typescript
+import { loadSchemaSync } from '@graphql-tools/load';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { join } from 'path';
+
+const schema = loadSchemaSync(join(__dirname, './*.graphql'), {
+    loaders: [new GraphQLFileLoader()],
+});
+
+export { schema };
+```
+
+**File**: `packages-modules/{module}/server/src/graphql/index.ts`
+
+```typescript
+export { resolvers } from './resolvers';
+export { schema } from './schemas';
+```
+
+**File**: `packages-modules/{module}/server/src/config/env-config.ts`
+
+```typescript
+import { str, cleanEnv, num, bool } from 'envalid';
+
+export const config = cleanEnv(
+    process.env,
+    {
+        NODE_ENV: str({ choices: ['production', 'test', 'staging', 'development'], default: 'production' }),
+
+        // Database Configuration
+        MONGO_URL: str({ desc: 'MongoDB connection string' }),
+
+        // Service-specific Configuration
+        {ENTITY_NAME}_AUTO_CLEANUP_ENABLED: bool({ default: false }),
+        {ENTITY_NAME}_CLEANUP_INTERVAL_HOURS: num({ default: 24 }),
+        {ENTITY_NAME}_MAX_RETENTION_DAYS: num({ default: 90 }),
+
+        // Feature Flags
+        {ENTITY_NAME}_NOTIFICATIONS_ENABLED: bool({ default: true }),
+        {ENTITY_NAME}_AUDIT_ENABLED: bool({ default: true }),
+
+        // External Service URLs
+        NOTIFICATION_SERVICE_URL: str({ default: '' }),
+        AUDIT_SERVICE_URL: str({ default: '' }),
+
+        // Security
+        {ENTITY_NAME}_RATE_LIMIT_PER_HOUR: num({ default: 100 }),
+
+        // GraphQL
+        GRAPHQL_URL: str({ desc: 'GraphQL endpoint URL' }),
+
+        // Common settings
+        APP_NAME: str({ default: 'CDEBASE.IO' }),
+        CLIENT_URL: str({ desc: 'Client application URL' }),
+    },
+);
+```
+
+### Phase 14: Container Module with createServiceFunc
+
+**File**: `packages-modules/{module}/server/src/containers/module.ts`
+
+```typescript
+import { ContainerModule, interfaces } from 'inversify';
+import { SERVER_TYPES } from 'common/server';
+import type {
+    I{EntityName}Service,
+    I{EntityName}Repository,
+    ServerContext
+} from 'common/server';
+import { {EntityName}ServiceExt } from '../services/{entity-name}-service-ext';
+import { {EntityName}Repository } from '../store/repositories/{entity-name}-repository';
+
+export const {entity}Module: (settings: any) => interfaces.ContainerModule = (settings: any) =>
+    new ContainerModule((bind: interfaces.Bind) => {
+        // MongoDB Connection
+        bind(SERVER_TYPES.I{Entity}MongoConnection).toConstantValue(settings.mongoConnection);
+
+        // Repository
+        bind<I{EntityName}Repository>(SERVER_TYPES.I{EntityName}Repository)
+            .to({EntityName}Repository as any)
+            .inSingletonScope()
+            .whenTargetIsDefault();
+
+        // Service (use ServiceExt for Moleculer integration)
+        bind<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service)
+            .to({EntityName}ServiceExt)
+            .inSingletonScope()
+            .whenTargetIsDefault();
+    });
+
+// Service creation function for ServerContext
+const createServiceFunc = (container: interfaces.Container): Partial<ServerContext> => ({
+    {entity}Service: container.get<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service),
+});
+
+export { createServiceFunc };
+```
+
+### Phase 14: Main Module File
+
+**File**: `packages-modules/{module}/server/src/module.ts`
+
+```typescript
+import { interfaces } from 'inversify';
+import { Feature } from '@common-stack/server-core';
+import type { ServerContext } from 'common/server';
+import { SERVER_TYPES, I{EntityName}Service } from 'common/server';
+import { {entity}Module, createServiceFunc } from './containers/module';
+import { resolvers, schema } from './graphql';
+import { rules } from './permissions';
+import { {EntityName}MoleculerService } from './plugins';
+
+// Service generation function - REQUIRED TYPE: (container: interfaces.Container) => Partial<ServerContext>
+const {entity}ServiceGen = (container: interfaces.Container): Partial<ServerContext> => {
+    const environment = container.get('Environment');
+    return {
+        {entity}Service: container.get<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service),
+    };
+};
+
+export default new Feature({
+    schema,
+    createResolversFunc: resolvers,
+    createContainerFunc: [{entity}Module],
+    createServiceFunc: {entity}ServiceGen, // This must return Partial<ServerContext>
+    rules,
+    addBrokerMainServiceClass: [{EntityName}MoleculerService],
+    middleware: [
+        // Add custom middleware here
+        (app) => {
+            app.get('/api/{entity}/health', (req, res) => {
+                res.json({ status: 'OK', service: '{entity}Service', timestamp: new Date().toISOString() });
+            });
+        },
+    ],
+});
+```
+
+### Phase 15: Main Module File
+
+**File**: `packages-modules/{module}/server/src/module.ts`
+
+```typescript
+import { interfaces } from 'inversify';
+import { Feature } from '@common-stack/server-core';
+import type { ServerContext } from 'common/server';
+import { SERVER_TYPES, I{EntityName}Service } from 'common/server';
+import { {entity}Module, createServiceFunc } from './containers/module';
+import { resolvers, schema } from './graphql';
+import { rules } from './permissions';
+import { {EntityName}MoleculerService } from './plugins';
+
+// Service generation function - REQUIRED TYPE: (container: interfaces.Container) => Partial<ServerContext>
+const {entity}ServiceGen = (container: interfaces.Container): Partial<ServerContext> => {
+    const environment = container.get('Environment');
+    return {
+        {entity}Service: container.get<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service),
+        {entity}DataLoader: container.get(SERVER_TYPES.{EntityName}DataLoader), // Include DataLoader
+    };
+};
+
+export default new Feature({
+    schema,
+    createResolversFunc: resolvers,
+    createContainerFunc: [{entity}Module],
+    createServiceFunc: {entity}ServiceGen, // This must return Partial<ServerContext>
+    rules,
+    addBrokerMainServiceClass: [{EntityName}MoleculerService],
+    middleware: [
+        // Add custom middleware here
+        (app) => {
+            app.get('/api/{entity}/health', (req, res) => {
+                res.json({ status: 'OK', service: '{entity}Service', timestamp: new Date().toISOString() });
+            });
+        },
+    ],
+});
+```
+
+### Phase 16: Index Files and Exports
+
+**File**: `packages-modules/{module}/server/src/store/models/index.ts`
+
+```typescript
+export { {EntityName}ModelFunc } from './{entity-name}-model';
+```
+
+**File**: `packages-modules/{module}/server/src/store/repositories/index.ts`
+
+```typescript
+export { {EntityName}Repository } from './{entity-name}-repository';
+```
+
+**File**: `packages-modules/{module}/server/src/services/index.ts`
+
+```typescript
+export { {EntityName}Service } from './{entity-name}-service';
+export { {EntityName}ServiceExt } from './{entity-name}-service-ext';
+```
+
+**File**: `packages-modules/{module}/server/src/dataloaders/index.ts`
+
+```typescript
+export { {EntityName}DataLoader } from './{entity-name}-data-loader';
+```
+
+**File**: `packages-modules/{module}/server/src/graphql/resolvers/index.ts`
+
+```typescript
+import { merge } from 'lodash-es';
+import { {entity}Resolvers } from './{entity-name}-resolver';
+
+export const resolvers = () => merge({entity}Resolvers);
+```
+
+**File**: `packages-modules/{module}/server/src/graphql/schemas/index.ts`
+
+```typescript
+import { loadSchemaSync } from '@graphql-tools/load';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { join } from 'path';
+
+const schema = loadSchemaSync(join(__dirname, './*.graphql'), {
+    loaders: [new GraphQLFileLoader()],
+});
+
+export { schema };
+```
+
+### Phase 17: Constants and Actions
+
+**File**: `packages-modules/{module}/server/src/constants/moleculer-actions.ts`
+
+```typescript
+export const {EntityName}ServiceAction = {
+    On{EntityName}Created: '{entity}.created',
+    On{EntityName}Updated: '{entity}.updated',
+    On{EntityName}Deleted: '{entity}.deleted',
+    On{EntityName}StatusChanged: '{entity}.status.changed',
+} as const;
+
+export const MoleculerServiceName = {
+    NotificationService: 'notification',
+    AuditService: 'audit',
+    ConfigurationService: 'configuration',
+} as const;
+```
+
+### Phase 18: Final Build and Verification
+
+```bash
+# 1. CRITICAL: Navigate to PROJECT ROOT (not module directory)
+cd /path/to/your/project-root
+
+# 2. CRITICAL: Regenerate templates and immediately generate types from ROOT
+# (regenerateGraphql can remove codegen files, so generateGraphql must follow immediately)
+yarn regenerateGraphql && yarn generateGraphql
+
+# 3. Build specific module using Lerna
+lerna exec --scope=@adminide-stack/{module}-module-server yarn build
+
+# Alternative builds:
+# For marketplace module specifically:
+lerna exec --scope=@adminide-stack/marketplace-module-server yarn build
+
+# For extension module:
+lerna exec --scope=@adminide-stack/extension-module-server yarn build
+
+# For general module build:
+yarn build
+
+# 5. Run tests
+yarn test
+
+# 6. Full monorepo build (if needed)
+yarn build:all
+```
+
+### Phase 19: Verification Checklist
+
+✅ **Files Created:**
+
+- [ ] GraphQL schema: `{entity}.graphql`
+- [ ] Event types: `service.graphql`
+- [ ] Templates: Service and Repository templates
+- [ ] Constants: DB_COLL_NAMES and SERVER_TYPES
+- [ ] Model: Mongoose schema with proper typing
+- [ ] Repository: Data access with BaseRepository
+- [ ] Service: Business logic with event emitters
+- [ ] ServiceExt: Moleculer broadcasting
+- [ ] Resolver: GraphQL operations
+- [ ] Container: Dependency injection bindings
+- [ ] Module: Feature integration with createServiceFunc
+- [ ] Config: Environment configuration
+- [ ] Constants: Moleculer actions and service names
+
+✅ **Generated Files:**
+
+- [ ] `packages/common/src/services/{EntityName}Service.ts`
+- [ ] `packages/common/src/repositories/{EntityName}Repository.ts`
+- [ ] `packages/common/src/constants/DB_COLL_NAMES.ts` (updated)
+- [ ] `packages/common/src/generated/generated-models.ts` (updated)
+
+✅ **Type Safety:**
+
+- [ ] All imports from `common/server` resolve
+- [ ] No TypeScript compilation errors
+- [ ] Proper ServerContext augmentation
+- [ ] Event types generated without @entity
+
+✅ **Architecture:**
+
+- [ ] Repository extends BaseRepository
+- [ ] Service extends BaseService
+- [ ] ServiceExt for Moleculer integration
+- [ ] Proper dependency injection
+- [ ] Event-driven architecture
+- [ ] Tenant isolation implemented
+- [ ] Audit fields included
+
+## 🎯 Key Patterns Summary
+
+### **1. Field Mapping Architecture**
+
+```typescript
+// GraphQL API Layer (human-readable)
+input InstallExtensionInput {
+    extensionID: String! // "publisher/extension-name"
+}
+
+// Database Layer (ObjectId references)
+type InstalledExtension @entity {
+    extension: RegistryExtension @column(overrideType: "ObjectId")
+}
+
+// Resolver handles the mapping
+const installInput = {
+    tenantId: userContext.tenantId,
+    registryRef: registryEntity._id, // ObjectId reference
+    extensionID, // Human-readable ID for API
+    installedVersion: registryEntity.version,
+    installedBy: userContext.userId,
+};
+```
+
+### **2. Service Creation Function Pattern**
+
+```typescript
+// REQUIRED signature for createServiceFunc
+const createServiceFunc = (container: interfaces.Container): Partial<ServerContext> => ({
+    {entity}Service: container.get<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service),
+});
+```
+
+### **3. Event System Pattern**
+
+```typescript
+// Events in service.graphql (NO @entity)
+type {EntityName}CreatedEvent {
+    {entity}Id: String!
+    tenantId: String!
+    // ... other fields
+}
+
+// Service emits events
+protected readonly on{EntityName}Created = new Emitter<I{EntityName}CreatedEvent>();
+```
+
+### **4. Repository Pattern**
+
+```typescript
+// Repository extends BaseRepository
+@injectable()
+export class {EntityName}Repository extends BaseRepository<I{EntityName}Model>
+    implements I{EntityName}Repository {
+
+    constructor(connection: Connection) {
+        const {EntityName}Model = {EntityName}ModelFunc(connection);
+        super({EntityName}Model);
+    }
+}
+```
+
+### **5. Container Binding Pattern**
+
+```typescript
+// Container module with proper typing
+bind<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service)
+    .to({EntityName}ServiceExt) // Use ServiceExt for Moleculer
+    .inSingletonScope()
+    .whenTargetIsDefault();
+```
+
+### **6. DataLoader Template Pattern**
+
+```typescript
+// File: packages-modules/{module}/server/src/templates/services/{EntityName}DataLoader.ts.template
+import { I{EntityName}, IDataLoader } from 'common/server';
+export type I{EntityName}DataLoader = IDataLoader<I{EntityName}>;
+```
+
+### **7. SERVER_TYPES for DataLoaders**
+
+```typescript
+// Add to SERVER_TYPES.ts (automatically generated from templates)
+export const SERVER_TYPES = {
+    // ... existing types
+    {EntityName}DataLoader: Symbol('{EntityName}DataLoader'),
+} as const;
+```
+
+## 🔄 **DataLoader Implementation for Object Resolution**
+
+### **Problem**:
+
+When GraphQL schema defines object relationships but database stores ObjectId references, you need DataLoaders to resolve these efficiently and prevent N+1 query problems.
+
+### **Solution Pattern**:
+
+#### **1. DataLoader Implementation**
+
+```typescript
+// File: packages-modules/{module}/server/src/dataloaders/{entity}-data-loader.ts
+import { I{EntityName}, I{EntityName}Service, SERVER_TYPES, IBaseService, AsDomainType } from 'common/server';
+import { injectable, inject } from 'inversify';
+import { BulkDataLoader2 } from '@common-stack/store-mongo';
+
+@injectable()
+export class {EntityName}DataLoader extends BulkDataLoader2<AsDomainType<I{EntityName}>> {
+    constructor(
+        @inject(SERVER_TYPES.I{EntityName}Service)
+        {entity}Service: I{EntityName}Service,
+    ) {
+        super({entity}Service as unknown as IBaseService<AsDomainType<I{EntityName}>>);
+    }
+}
+```
+
+#### **2. Field Resolver with DataLoader**
+
+```typescript
+// In your GraphQL resolver
+{ParentEntity}: {
+    // Field resolver for object references using DataLoaders
+    {relationField}: (root, args, { {entity}DataLoader }) => {
+        // CRITICAL: Check if relation field exists and is not null before calling dataloader
+        if (!root.{relationField} || root.{relationField} === null || root.{relationField} === undefined) {
+            return null;
+        }
+        const relationId = String(root.{relationField}); // Convert ObjectId to string
+        return {entity}DataLoader.load(relationId);
+    },
+
+    // Example: Resolving organization from ObjectId reference
+    organization: (root, args, { organizationDataLoader }) => {
+        // Check if organization exists and is not null/undefined before calling dataloader
+        if (!root.organization || root.organization === null || root.organization === undefined) {
+            return null;
+        }
+        const orgId = String(root.organization);
+        return organizationDataLoader.load(orgId);
+    },
+
+    // Example: Resolving user from ObjectId reference
+    user: (root, args, { accountUserDataLoader }) => {
+        // Check if user exists and is not null/undefined before calling dataloader
+        if (!root.user || root.user === null || root.user === undefined) {
+            return null;
+        }
+        const userId = String(root.user);
+        return accountUserDataLoader.load(userId);
+    },
+
+    // Example: Resolving extension from ObjectId reference in installed extension
+    extension: (root, args, { registryExtensionDataLoader }) => {
+        if (!root.extension || root.extension === null || root.extension === undefined) {
+            return null;
+        }
+        const extensionID = String(root.extension);
+        return registryExtensionDataLoader.load(extensionID);
+    },
+},
+```
+
+#### **3. Context Integration**
+
+```typescript
+// Context interface must include DataLoaders
+interface I{EntityName}Context extends ServerContext {
+    // Service dependencies
+    {entity}Service: I{EntityName}Service;
+    organizationService: IOrganizationService;
+
+    // DataLoader dependencies for resolving ObjectId references
+    {entity}DataLoader: {EntityName}DataLoader;
+    organizationDataLoader: OrganizationDataLoader;
+    accountUserDataLoader: AccountUserDataLoader;
+    registryExtensionDataLoader: RegistryExtensionDataLoader;
+
+    // User context
+    userContext: {
+        tenantId: string;
+        userId: string;
+        accountId: string;
+        emailId: string;
+        organization?: {
+            id: string;
+            name: string;
+        };
+    };
+}
+```
+
+#### **4. Container Module DataLoader Registration**
+
+```typescript
+// File: packages-modules/{module}/server/src/containers/module.ts
+import { {EntityName}DataLoader } from '../dataloaders/{entity}-data-loader';
+
+export const {entity}Module: (settings: any) => interfaces.ContainerModule = (settings: any) =>
+    new ContainerModule((bind: interfaces.Bind) => {
+        // ... existing bindings
+
+        // DataLoader - CRITICAL: Use request scope for caching
+        bind<{EntityName}DataLoader>(SERVER_TYPES.{EntityName}DataLoader)
+            .to({EntityName}DataLoader)
+            .inRequestScope(); // Important: Request scope for DataLoader caching
+    });
+
+// Update createServiceFunc to include DataLoader
+const createServiceFunc = (container: interfaces.Container): Partial<ServerContext> => ({
+    {entity}Service: container.get<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service),
+    {entity}DataLoader: container.get<{EntityName}DataLoader>(SERVER_TYPES.{EntityName}DataLoader),
+});
+```
+
+### **🔧 CRITICAL: Template Configuration for DataLoaders**
+
+#### **1. Add DataLoader Templates to package.json**
+
+```json
+{
+    "cdecode": {
+        "common": {
+            "constants": [
+                "./${libDir}/templates/constants/SERVER_TYPES.ts.template",
+                "./${libDir}/templates/constants/DB_COLL_NAMES.ts.template"
+            ],
+            "services": [
+                "./${libDir}/templates/services/{EntityName}Service.ts.template",
+                "./${libDir}/templates/services/{EntityName}DataLoader.ts.template"
+            ],
+            "repositories": ["./${libDir}/templates/repositories/{EntityName}Repository.ts.template"]
+        }
+    }
+}
+```
+
+#### **2. Create DataLoader Template File**
+
+```typescript
+// File: packages-modules/{module}/server/src/templates/services/{EntityName}DataLoader.ts.template
+import { I{EntityName}, IDataLoader } from 'common/server';
+export type I{EntityName}DataLoader = IDataLoader<I{EntityName}>;
+```
+
+#### **3. Add SERVER_TYPES Template**
+
+```typescript
+// File: packages-modules/{module}/server/src/templates/constants/SERVER_TYPES.ts.template
+export const SERVER_TYPES = {
+    // ... existing types from other modules
+
+    // Add DataLoader types for this module
+    {EntityName}DataLoader: Symbol('{EntityName}DataLoader'),
+};
+```
+
+#### **4. Regenerate Types**
+
+```bash
+# Run these commands to regenerate templates
+yarn regenerateGraphql
+yarn generateGraphql
+```
+
+This will automatically:
+
+- Generate `I{EntityName}DataLoader` type in `common/server`
+- Add `{EntityName}DataLoader` to SERVER_TYPES constants
+- Make DataLoader available in GraphQL context for resolvers
+
+#### **5. GraphQL Schema Definition**
+
+```graphql
+# Schema showing ObjectId stored as references but resolved as objects
+type InstalledExtension @entity {
+    id: ID!
+    tenantId: String! @column
+
+    # Database stores ObjectId reference to RegistryExtension
+    extension: RegistryExtension @column(overrideType: "ObjectId")
+
+    # Database stores string but resolves to object via DataLoader
+    extensionID: String! @column
+
+    installedVersion: String! @column
+    installedBy: String! @column
+
+    createdAt: Date! @column(overrideType: "Date")
+    updatedAt: Date! @column(overrideType: "Date")
+}
+
+type RegistryExtension @entity {
+    id: ID!
+    extensionID: String! @column
+    version: String! @column
+    name: String! @column
+    # ... other fields
+}
+```
+
+#### **6. Complete Real-World Example: Installed Extension**
+
+```typescript
+export const resolvers: (options: IResolverOptions) => IResolvers = (options) => ({
+    // Field resolvers for InstalledExtension
+    InstalledExtension: {
+        // Resolve extension ObjectId reference to actual RegistryExtension object
+        extension: (root, args, { registryExtensionDataLoader }) => {
+            if (!root.extension || root.extension === null || root.extension === undefined) {
+                return null;
+            }
+            const extensionID = String(root.extension); // Convert ObjectId to string
+            return registryExtensionDataLoader.load(extensionID);
+        },
+
+        // Resolve installedBy ObjectId reference to User object
+        installedByUser: (root, args, { accountUserDataLoader }) => {
+            if (!root.installedBy || root.installedBy === null || root.installedBy === undefined) {
+                return null;
+            }
+            const userId = String(root.installedBy);
+            return accountUserDataLoader.load(userId);
+        },
+
+        // Computed field combining data from both sources
+        displayName: async (root, args, { registryExtensionDataLoader }) => {
+            if (!root.extension) return root.extensionID;
+
+            const extension = await registryExtensionDataLoader.load(String(root.extension));
+            return extension ? extension.name : root.extensionID;
+        },
+    },
+
+    // Query resolvers
+    Query: {
+        getInstalledExtensions: async (
+            _: any,
+            { filter }: { filter?: any },
+            { installedExtensionService, userContext }: InstalledExtensionContext,
+        ): Promise<IInstalledExtensionModel[]> => {
+            options.logger.trace('(Query.getInstalledExtensions) filter [%j]', filter);
+
+            if (!userContext?.tenantId) {
+                throw new Error('Authentication required');
+            }
+
+            const searchFilter = {
+                tenantId: userContext.tenantId,
+                ...filter,
+            };
+
+            // Service returns models with ObjectId references
+            // Field resolvers will use DataLoaders to resolve them to actual objects
+            return await installedExtensionService.getInstalledExtensions(searchFilter);
+        },
+    },
+
+    // Mutation resolvers
+    Mutation: {
+        installExtension: async (
+            _: any,
+            { extensionID }: { extensionID: string },
+            { installedExtensionService, registryExtensionService, userContext }: InstalledExtensionContext,
+        ) => {
+            options.logger.trace('(Mutation.installExtension) extensionID [%j]', extensionID);
+
+            if (!userContext?.tenantId || !userContext?.userId) {
+                throw new Error('Authentication required');
+            }
+
+            try {
+                // First get the registry extension (this will be stored as ObjectId reference)
+                const extension = await registryExtensionService.findExtension(extensionID);
+                if (!extension) {
+                    throw new Error(`Extension ${extensionID} not found`);
+                }
+
+                // Install extension - stores extension._id as ObjectId reference
+                const installInput = {
+                    tenantId: userContext.tenantId,
+                    extension: extension._id, // ObjectId reference
+                    extensionID, // Human-readable ID
+                    installedVersion: extension.version,
+                    installedBy: userContext.userId, // Also ObjectId reference
+                };
+
+                const result = await installedExtensionService.installExtension(installInput);
+
+                // When returned, field resolvers will use DataLoaders to resolve:
+                // - result.extension (ObjectId) → RegistryExtension object
+                // - result.installedBy (ObjectId) → User object
+
+                return result;
+            } catch (error) {
+                options.logger.error('Error installing extension:', error);
+                throw error;
+            }
+        },
+    },
+});
+```
+
+### **Key Benefits of DataLoader Pattern:**
+
+1. **Performance**: Prevents N+1 query problems by batching database requests
+2. **Caching**: DataLoaders cache results within a single request
+3. **Type Safety**: Resolves ObjectId references to properly typed objects
+4. **Clean Separation**: Database stores efficient ObjectId references, GraphQL returns rich objects
+5. **Consistency**: All object references resolved through same pattern
+
+### **Critical Implementation Notes:**
+
+1. **Null Checks**: Always check if reference field exists before calling DataLoader
+2. **String Conversion**: Convert ObjectId to string before passing to DataLoader
+3. **Request Scope**: DataLoaders should be bound in request scope for proper caching
+4. **Field Mapping**: Database stores ObjectId, GraphQL schema exposes as object type
+5. **Error Handling**: DataLoaders handle missing references gracefully by returning null
+6. **Type Casting**: When field resolvers use DataLoaders to resolve ObjectId references, you must cast return types in queries/mutations
+
+### **Type Casting Pattern for DataLoader Resolvers:**
+
+When you have field resolvers that use DataLoaders to resolve ObjectId references to objects, the service layer returns `Model` types but GraphQL expects the interface types. You need to cast the return types:
+
+```typescript
+// Query resolvers need type casting
+Query: {
+    // Single object query
+    get{EntityName}: async (_, { id }, { {entity}Service, userContext }) => {
+        return await {entity}Service.get{EntityName}(id, userContext.tenantId) as unknown as I{EntityName};
+    },
+
+    // Array query
+    list{EntityName}s: async (_, { filter }, { {entity}Service, userContext }) => {
+        const result = await {entity}Service.list{EntityName}s({
+            tenantId: userContext.tenantId,
+            ...filter,
+        });
+        return result as unknown as I{EntityName}[];
+    },
+},
+
+// Mutation resolvers also need type casting
+Mutation: {
+    create{EntityName}: async (_, { input }, { {entity}Service, userContext }) => {
+        const result = await {entity}Service.create{EntityName}({
+            ...input,
+            tenantId: userContext.tenantId,
+            createdBy: userContext.accountId,
+        });
+        return result as unknown as I{EntityName};
+    },
+
+    // When returning objects in mutation responses
+    installExtension: async (_, { input }, { installedExtensionService, userContext }) => {
+        const installedExtension = await installedExtensionService.installExtension({
+            ...input,
+            tenantId: userContext.tenantId,
+            installedBy: userContext.accountId,
+        });
+
+        return {
+            success: true,
+            extension: installedExtension as unknown as IInstalledExtension,
+            message: `Extension installed successfully`,
+        };
+    },
+},
+```
+
+### **Why Type Casting is Required:**
+
+1. **Service Layer**: Returns `I{EntityName}Model` (Mongoose document with ObjectId fields)
+2. **GraphQL Schema**: Expects `I{EntityName}` (interface with resolved object references)
+3. **Field Resolvers**: Use DataLoaders to transform ObjectId → actual objects during GraphQL execution
+4. **Type System**: TypeScript can't infer that field resolvers will handle the transformation
+
+### **Example with InstalledExtension:**
+
+```typescript
+// Database stores this
+type IInstalledExtensionModel = {
+    _id: ObjectId;
+    extension: ObjectId; // Reference to RegistryExtension
+    extensionID: string;
+    tenantId: string;
+    // ...
+}
+
+// GraphQL expects this after field resolution
+type IInstalledExtension = {
+    id: string;
+    extension: IRegistryExtension; // Resolved object via DataLoader
+    extensionID: string;
+    tenantId: string;
+    // ...
+}
+
+// Field resolver handles the transformation
+InstalledExtension: {
+    extension: (root, args, { registryExtensionDataLoader }) => {
+        if (!root.extension) return null;
+        return registryExtensionDataLoader.load(String(root.extension)); // ObjectId → IRegistryExtension
+    },
+}
+
+// Query must cast the type
+Query: {
+    installedExtensions: async (_, args, { installedExtensionService, userContext }) => {
+        // Service returns IInstalledExtensionModel[]
+        const result = await installedExtensionService.getInstalledExtensions({
+            tenantId: userContext.tenantId
+        });
+        // Cast to what GraphQL expects - field resolver will handle extension transformation
+        return result as unknown as IInstalledExtension[];
+    }
+}
+```
+
+This pattern ensures efficient object resolution while maintaining clean GraphQL schemas and preventing performance issues.
+
+## 🎯 **Complete DataLoader Implementation Checklist**
+
+When implementing DataLoaders for object resolution, follow this complete checklist:
+
+### ✅ **1. Create DataLoader Class**
+
+```typescript
+// File: src/dataloaders/{entity}-data-loader.ts
+@injectable()
+export class {EntityName}DataLoader extends BulkDataLoader2<AsDomainType<I{EntityName}>> {
+    constructor(@inject(SERVER_TYPES.I{EntityName}Service) {entity}Service: I{EntityName}Service) {
+        super({entity}Service as unknown as IBaseService<AsDomainType<I{EntityName}>>);
+    }
+}
+```
+
+### ✅ **2. Add to SERVER_TYPES**
+
+```typescript
+// packages/common/src/constants/SERVER_TYPES.ts
+I{EntityName}DataLoader: Symbol.for('I{EntityName}DataLoader'),
+```
+
+### ✅ **3. Register in Container**
+
+```typescript
+// src/containers/module.ts
+bind<{EntityName}DataLoader>(SERVER_TYPES.I{EntityName}DataLoader)
+    .to({EntityName}DataLoader)
+    .inRequestScope();
+```
+
+### ✅ **4. Add to Service Context**
+
+```typescript
+// src/containers/module.ts - createServiceFunc
+const createServiceFunc = (container: interfaces.Container) => ({
+    {entity}DataLoader: container.get<{EntityName}DataLoader>(SERVER_TYPES.I{EntityName}DataLoader),
+});
+```
+
+### ✅ **5. Create Field Resolvers**
+
+```typescript
+// src/graphql/resolvers/{entity}-resolver.ts
+{ParentEntity}: {
+    {relationField}: (root, args, { {entity}DataLoader }) => {
+        if (!root.{relationField}) return null;
+        return {entity}DataLoader.load(String(root.{relationField}));
+    },
+}
+```
+
+### ✅ **6. Add Type Casting in Queries/Mutations**
+
+```typescript
+Query: {
+    get{EntityName}: async (_, { id }, { {entity}Service }) => {
+        const result = await {entity}Service.get{EntityName}(id);
+        return result as unknown as I{EntityName};
+    },
+}
+```
+
+### ✅ **7. Run Template Regeneration**
+
+```bash
+yarn regenerateGraphql && yarn generateGraphql
+```
+
+This complete implementation ensures proper DataLoader integration with the adminIde-stack architecture! 🚀
+
+## 📋 **Complete GraphQL Resolver Architecture Pattern**
+
+### **File Structure:**
+
+```
+src/graphql/resolvers/
+├── index.ts                    # Resolver combination and export
+├── {entity-name}-resolver.ts   # Individual entity resolvers
+├── registry-extension-resolver.ts
+├── installed-extension-resolver.ts
+└── ...
+```
+
+### **Individual Resolver Structure:**
+
+```typescript
+// File: {entity-name}-resolver.ts
+import { PubSub } from 'graphql-subscriptions';
+import { CdmLogger } from '@cdm-logger/core';
+import { I{EntityName}, IResolvers } from 'common/server';
+
+export const resolver = (pubsub: PubSub, logger?: CdmLogger.ILogger): IResolvers => ({
+    // 1. Field Resolvers - Handle ObjectId → Object transformations
+    {EntityName}: {
+        {relationField}: (root, args, { {relation}DataLoader }) => {
+            if (!root.{relationField}) return null;
+            return {relation}DataLoader.load(String(root.{relationField}));
+        },
+    },
+
+    // 2. Query Resolvers - Always cast return types
+    Query: {
+        get{EntityName}: async (_, { id }, { {entity}Service, userContext }) => {
+            if (!userContext?.tenantId) throw new Error('Authentication required');
+            const result = await {entity}Service.get{EntityName}(id, userContext.tenantId);
+            return result as unknown as I{EntityName};
+        },
+    },
+
+    // 3. Mutation Resolvers - Always cast return types
+    Mutation: {
+        create{EntityName}: async (_, { input }, { {entity}Service, userContext }) => {
+            if (!userContext?.tenantId) throw new Error('Authentication required');
+            const result = await {entity}Service.create{EntityName}({
+                ...input,
+                tenantId: userContext.tenantId,
+                createdBy: userContext.accountId,
+            });
+            return result as unknown as I{EntityName};
+        },
+    },
+});
+```
+
+### **Index Resolver Combination:**
+
+```typescript
+// File: index.ts
+import { resolver as entityResolver } from './{entity-name}-resolver';
+import { resolver as registryResolver } from './registry-extension-resolver';
+
+export const resolvers = [entityResolver, registryResolver];
+```
+
+### **Context Integration Pattern:**
+
+The resolvers receive context with these properties:
+
+- `userContext`: Authentication and tenant information
+- `{entity}Service`: Business logic services
+- `{entity}DataLoader`: Efficient object resolution
+- `pubsub`: GraphQL subscriptions (if needed)
+- `logger`: Logging functionality
+
+### **Critical Rules:**
+
+1. **🔑 Authentication**: Always check `userContext?.tenantId` in resolvers
+2. **🔄 Type Casting**: Always use `as unknown as I{EntityName}` for service returns
+3. **🚀 DataLoaders**: Use for all ObjectId → Object field resolutions
+4. **🛡️ Null Checks**: Check field existence before calling DataLoaders
+5. **📝 Logging**: Log important operations for debugging
+6. **🎯 Context**: Use proper destructuring for clean code
+
+## 🎯 **CRITICAL: DataLoader Requirements for LLM Service Creation**
+
+### **Mandatory Steps When Creating Any New Service:**
+
+1. **Create DataLoader Template**:
+
+    ```typescript
+    // File: src/templates/services/{EntityName}DataLoader.ts.template
+    import { I{EntityName}, IDataLoader } from 'common/server';
+    export type I{EntityName}DataLoader = IDataLoader<I{EntityName}>;
+    ```
+
+2. **Add to package.json cdecode**:
+
+    ```json
+    "services": [
+      "./${libDir}/templates/services/{EntityName}Service.ts.template",
+      "./${libDir}/templates/services/{EntityName}DataLoader.ts.template"
+    ]
+    ```
+
+3. **Add SERVER_TYPES symbols**:
+
+    ```typescript
+    // In templates/constants/SERVER_TYPES.ts.template
+    {EntityName}DataLoader: Symbol('{EntityName}DataLoader'),
+    ```
+
+4. **Container Binding (Request Scope)**:
+
+    ```typescript
+    bind<{EntityName}DataLoader>(SERVER_TYPES.{EntityName}DataLoader)
+      .to({EntityName}DataLoader)
+      .inRequestScope(); // CRITICAL for caching
+    ```
+
+5. **Include in createServiceFunc**:
+
+    ```typescript
+    const createServiceFunc = (container: interfaces.Container): Partial<ServerContext> => ({
+      {entity}Service: container.get<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service),
+      {entity}DataLoader: container.get<{EntityName}DataLoader>(SERVER_TYPES.{EntityName}DataLoader),
+    });
+    ```
+
+6. **Field Resolver Pattern**:
+    ```typescript
+    {relationField}: (root, args, { {entity}DataLoader }) => {
+      if (!root.{relationField} || root.{relationField} === null || root.{relationField} === undefined) {
+        return null;
+      }
+      const relationId = String(root.{relationField});
+      return {entity}DataLoader.load(relationId);
+    },
+    ```
+
+### **Why This Matters:**
+
+- **Performance**: Prevents N+1 query problems
+- **Type Safety**: Generated types ensure consistent context
+- **Maintainability**: Templates ensure all services follow same pattern
+- **Regeneration**: `yarn regenerateGraphql` updates all types automatically
+
+**⚠️ CRITICAL**:
+
+- Always run `yarn regenerateGraphql && yarn generateGraphql` from PROJECT ROOT (not module directory)
+- These commands must be run in sequence after creating DataLoader templates to generate proper types in common/server package
+- Running from module directory will fail - commands only work from project root
+
+This comprehensive template covers all aspects of creating a backend service following the established patterns. Use this as a complete guide for LLM-assisted development of similar services.
+
+## 🧪 Phase 19: Service Testing
+
+**File**: `packages-modules/{module}/server/src/services/{entity-name}-service.test.ts`
+
+```typescript
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import mongoose from 'mongoose';
+import { CdmLogger } from '@cdm-logger/core';
+import {
+    I{EntityName}Model,
+    I{EntityName}Service,
+    ICreate{EntityName}ServerInput,
+    IUpdate{EntityName}ServerInput,
+    I{EntityName}Filter,
+    {EntityName}Status,
+} from 'common/server';
+import { {EntityName}Service } from './{entity-name}-service';
+
+// Mock dependencies
+const mockBroker = {
+    broadcast: jest.fn(),
+    emit: jest.fn(),
+};
+
+describe('{EntityName}Service', () => {
+    let mongoServer: MongoMemoryServer;
+    let connection: mongoose.Connection;
+    let {entity}Service: {EntityName}Service;
+    let mock{EntityName}Repository: any;
+    let logger: CdmLogger.ILogger;
+
+    beforeAll(async () => {
+        mongoServer = await MongoMemoryServer.create();
+        const mongoUri = mongoServer.getUri();
+        connection = await mongoose.createConnection(mongoUri);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    });
+
+    beforeEach(() => {
+        // Initialize logger mock
+        logger = {
+            child: () => logger,
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+        } as any;
+
+        // Mock repository with all required methods
+        mock{EntityName}Repository = {
+            create: jest.fn(),
+            update: jest.fn(),
+            findById: jest.fn(),
+            find: jest.fn(),
+            delete: jest.fn(),
+            exists: jest.fn(),
+            updateStatus: jest.fn(),
+            count: jest.fn(),
+        };
+
+        // Initialize service with mocked dependencies
+        {entity}Service = new {EntityName}Service(
+            mock{EntityName}Repository,
+            mockBroker as any,
+            logger,
+        );
+    });
+
+    afterAll(async () => {
+        await connection.close();
+        await mongoServer.stop();
+    });
+
+    // Test helpers
+    const createMock{EntityName} = (overrides: Partial<I{EntityName}Model> = {}): I{EntityName}Model => ({
+        _id: new mongoose.Types.ObjectId(),
+        tenantId: 'test-tenant',
+        {fieldName}: 'test-value',
+        status: {EntityName}Status.Active,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        createdBy: new mongoose.Types.ObjectId(),
+        ...overrides,
+    } as I{EntityName}Model);
+
+    const createInput = (overrides: Partial<ICreate{EntityName}ServerInput> = {}): ICreate{EntityName}ServerInput => ({
+        {fieldName}: 'test-value',
+        tenantId: 'test-tenant',
+        createdBy: new mongoose.Types.ObjectId().toString(),
+        ...overrides,
+    });
+
+    describe('create{EntityName}', () => {
+        it('should create a new {entity} successfully', async () => {
+            // Arrange
+            const input = createInput();
+            const mock{EntityName} = createMock{EntityName}();
+
+            mock{EntityName}Repository.exists.mockResolvedValue(false);
+            mock{EntityName}Repository.create.mockResolvedValue(mock{EntityName});
+
+            // Act
+            const result = await {entity}Service.create{EntityName}(input);
+
+            // Assert
+            expect(result).toBeDefined();
+            expect(result.tenantId).toBe(input.tenantId);
+            expect(mock{EntityName}Repository.create).toHaveBeenCalledWith(input);
+        });
+
+        it('should throw error when {entity} already exists', async () => {
+            // Arrange
+            const input = createInput();
+            mock{EntityName}Repository.exists.mockResolvedValue(true);
+
+            // Act & Assert
+            await expect({entity}Service.create{EntityName}(input)).rejects.toThrow(
+                '{EntityName} with {fieldName}'
+            );
+        });
+    });
+
+    describe('update{EntityName}', () => {
+        it('should update an existing {entity}', async () => {
+            // Arrange
+            const id = new mongoose.Types.ObjectId().toString();
+            const tenantId = 'test-tenant';
+            const current = createMock{EntityName}();
+            const updated = { ...current, {fieldName}: 'updated-value' };
+            const updateInput: IUpdate{EntityName}ServerInput = {
+                {fieldName}: 'updated-value',
+                updatedBy: new mongoose.Types.ObjectId().toString(),
+            };
+
+            mock{EntityName}Repository.findById.mockResolvedValue(current);
+            mock{EntityName}Repository.update.mockResolvedValue(updated);
+
+            // Act
+            const result = await {entity}Service.update{EntityName}(id, updateInput);
+
+            // Assert
+            expect(result).toBeDefined();
+            expect(result.{fieldName}).toBe('updated-value');
+            expect(mock{EntityName}Repository.update).toHaveBeenCalledWith(id, updateInput);
+        });
+
+        it('should throw error when {entity} not found', async () => {
+            // Arrange
+            const id = new mongoose.Types.ObjectId().toString();
+            const updateInput: IUpdate{EntityName}ServerInput = {
+                {fieldName}: 'updated-value',
+                updatedBy: new mongoose.Types.ObjectId().toString(),
+            };
+
+            mock{EntityName}Repository.findById.mockResolvedValue(null);
+
+            // Act & Assert
+            await expect({entity}Service.update{EntityName}(id, updateInput)).rejects.toThrow(
+                '{EntityName} not found'
+            );
+        });
+    });
+
+    describe('get{EntityName}', () => {
+        it('should return {entity} when found', async () => {
+            // Arrange
+            const id = new mongoose.Types.ObjectId().toString();
+            const tenantId = 'test-tenant';
+            const mock{EntityName} = createMock{EntityName}();
+
+            mock{EntityName}Repository.findById.mockResolvedValue(mock{EntityName});
+
+            // Act
+            const result = await {entity}Service.get{EntityName}(id, tenantId);
+
+            // Assert
+            expect(result).toBeDefined();
+            expect(result!.tenantId).toBe(tenantId);
+        });
+
+        it('should return null when not found', async () => {
+            // Arrange
+            const id = new mongoose.Types.ObjectId().toString();
+            const tenantId = 'test-tenant';
+
+            mock{EntityName}Repository.findById.mockResolvedValue(null);
+
+            // Act
+            const result = await {entity}Service.get{EntityName}(id, tenantId);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('list{EntityName}s', () => {
+        it('should return all {entity} entities for tenant', async () => {
+            // Arrange
+            const mock{EntityName}s = [
+                createMock{EntityName}({ {fieldName}: 'entity-1' }),
+                createMock{EntityName}({ {fieldName}: 'entity-2' }),
+            ];
+
+            mock{EntityName}Repository.find.mockResolvedValue(mock{EntityName}s);
+
+            const filter: I{EntityName}Filter = { tenantId: 'test-tenant' };
+
+            // Act
+            const result = await {entity}Service.list{EntityName}s(filter);
+
+            // Assert
+            expect(result).toHaveLength(2);
+            expect(result.every(e => e.tenantId === 'test-tenant')).toBe(true);
+        });
+
+        it('should handle empty results', async () => {
+            // Arrange
+            mock{EntityName}Repository.find.mockResolvedValue([]);
+
+            // Act
+            const result = await {entity}Service.list{EntityName}s({ tenantId: 'empty-tenant' });
+
+            // Assert
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('delete{EntityName}', () => {
+        it('should delete existing {entity}', async () => {
+            // Arrange
+            const id = new mongoose.Types.ObjectId().toString();
+            const tenantId = 'test-tenant';
+            const mock{EntityName} = createMock{EntityName}();
+
+            mock{EntityName}Repository.findById.mockResolvedValue(mock{EntityName});
+            mock{EntityName}Repository.delete.mockResolvedValue(true);
+
+            // Act
+            const result = await {entity}Service.delete{EntityName}(id, tenantId, 'user-id');
+
+            // Assert
+            expect(result).toBe(true);
+            expect(mock{EntityName}Repository.delete).toHaveBeenCalledWith(id, tenantId);
+        });
+
+        it('should throw error when {entity} not found', async () => {
+            // Arrange
+            const id = new mongoose.Types.ObjectId().toString();
+            const tenantId = 'test-tenant';
+
+            mock{EntityName}Repository.findById.mockResolvedValue(null);
+
+            // Act & Assert
+            await expect({entity}Service.delete{EntityName}(id, tenantId, 'user-id')).rejects.toThrow(
+                '{EntityName} not found'
+            );
+        });
+    });
+
+    describe('error handling', () => {
+        it('should handle repository errors gracefully', async () => {
+            // Arrange
+            const input = createInput();
+            mock{EntityName}Repository.exists.mockRejectedValue(new Error('Database error'));
+
+            // Act & Assert
+            await expect({entity}Service.create{EntityName}(input)).rejects.toThrow('Database error');
+        });
+    });
+
+    describe('event system', () => {
+        it('should emit events on {entity} operations', async () => {
+            // Arrange
+            const input = createInput();
+            const mock{EntityName} = createMock{EntityName}();
+
+            mock{EntityName}Repository.exists.mockResolvedValue(false);
+            mock{EntityName}Repository.create.mockResolvedValue(mock{EntityName});
+
+            // Act
+            await {entity}Service.create{EntityName}(input);
+
+            // Assert - Events are emitted through service emitters
+            expect(mockBroker).toBeDefined();
+        });
+    });
+});
+```
+
+### Test Running Commands
+
+```bash
+# Run specific service tests
+cd packages-modules/{module}/server
+yarn test --testPathPattern='{entity-name}-service.test.ts'
+
+# Run all tests with coverage
+yarn test --coverage
+
+# Run tests in watch mode during development
+yarn test --watch
+```
+
+### Test Best Practices
+
+1. **Use Real Implementations**: Use actual MongoDB in-memory server for integration testing
+2. **Mock Dependencies**: Mock external services and repositories for unit testing
+3. **Test Business Logic**: Focus on service business logic, not repository implementation
+4. **Event Testing**: Verify events are emitted correctly through service emitters
+5. **Error Scenarios**: Test all error conditions and edge cases
+6. **Data Validation**: Test input validation and business rule enforcement
+
+This comprehensive template covers all aspects of creating a backend service following the established patterns. Use this as a complete guide for LLM-assisted development of similar services.
+{entityName}(id: ID!): {EntityName}
+{entityNamePlural}(filter: {EntityName}Filter): [{EntityName}!]!
+}
+
+# Mutations
+
+extend type Mutation {
+create{EntityName}(input: {EntityName}Input!): {EntityName}!
+update{EntityName}(id: ID!, input: Update{EntityName}Input!): {EntityName}!
+delete{EntityName}(id: ID!): Boolean!
+}
+
+````
+
+**Key Principles**:
+- Use `@entity` for database-mapped types
+- Use `@column` for database fields
+- Use `@column(overrideType: "ObjectId")` for object references
+- Use `@column(overrideType: "Date")` for timestamps
+- Use `@embedded` for nested objects
+- No `@entity` directive for pure input types or event types
+
+### 2. Database Collection Names
+**Location**: `packages-modules/{module}/server/src/templates/constants/DB_COLL_NAMES.ts.template`
+
+```typescript
+// Add to existing DB_COLL_NAMES constant
+export const DB_COLL_NAMES = {
+    // ... existing collections
+    {EntityName}: '{module}_{entity_name}',
+    // Example: InstalledExtension: 'marketplace_installed_extensions'
+} as const;
+````
+
+**Map in package.json cdecode**:
+
+```json
+{
+    "cdecode": {
+        "templates": {
+            "constants": {
+                "src": "src/templates/constants",
+                "dest": "../../packages/common/src/constants"
+            }
+        }
+    }
+}
+```
+
+### 3. Mongoose Model
+
+**Location**: `packages-modules/{module}/server/src/store/models/{entity}-model.ts`
+
+```typescript
+import {
+    DB_COLL_NAMES,
+    I{EntityName}Model,
+    // Import embedded type interfaces
+} from 'common/server';
+import { Connection, Schema } from 'mongoose';
+
+// Embedded Schemas First
+const {EmbeddedType}Schema = new Schema<I{EmbeddedType}Model>({
+    {field}: {
+        type: String,
+        required: true,
+    },
+    {optionalField}: {
+        type: String,
+    },
+});
+
+// Main Schema
+const {EntityName}Schema = new Schema<I{EntityName}Model>(
+    {
+        tenantId: {
+            type: String,
+            required: true,
+            index: true,
+        },
+        {relationField}: {
+            type: Schema.Types.ObjectId,
+            ref: DB_COLL_NAMES.{RelatedEntity},
+            required: true,
+            index: true,
+        },
+        {fieldName}: {
+            type: String,
+            required: true,
+        },
+        {embeddedField}: {
+            type: {EmbeddedType}Schema,
+            default: () => ({}),
+        },
+        createdBy: {
+            type: Schema.Types.ObjectId,
+            ref: DB_COLL_NAMES.Accounts,
+            required: true,
+        },
+    },
+    {
+        timestamps: { createdAt: 'createdAt', updatedAt: 'updatedAt' },
+        collection: DB_COLL_NAMES.{EntityName},
+    }
+);
+
+// Indexes
+{EntityName}Schema.index({ tenantId: 1, {keyField}: 1 }, { unique: true });
+
+// Virtuals (for GraphQL id field)
+{EntityName}Schema.virtual('id').get(function () {
+    return this._id.toHexString();
+});
+
+// Transform for JSON output
+{EntityName}Schema.set('toJSON', {
+    virtuals: true,
+    transform: (doc, ret) => {
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+    },
+});
+
+export const {EntityName}ModelFunc = (connection: Connection) => {
+    return connection.model<I{EntityName}Model>(DB_COLL_NAMES.{EntityName}, {EntityName}Schema);
+};
+```
+
+### 4. Service Templates
+
+**Location**: `packages-modules/{module}/server/src/templates/services/{EntityName}Service.ts.template`
+
+```typescript
+import {
+    I{EntityName}Model,
+    I{EntityName}Input,
+    IUpdate{EntityName}Input,
+    I{EmbeddedType}Input,
+} from 'common/server';
+
+/**
+ * Input type for creating {entityName} with additional server-side fields
+ */
+export interface ICreate{EntityName}Input extends I{EntityName}Input {
+    tenantId: string;
+    createdBy: string; // User ObjectId as string
+}
+
+/**
+ * Input type for updating {entityName}
+ */
+export interface IUpdate{EntityName}Input {
+    {field}?: string;
+    {embeddedField}?: I{EmbeddedType}Input;
+    updatedBy?: string;
+}
+
+/**
+ * Filter input for querying {entityName}
+ */
+export interface I{EntityName}Filter {
+    tenantId?: string;
+    {keyField}?: string;
+    createdBy?: string;
+}
+
+/**
+ * Service interface for managing {entityName}
+ */
+export interface I{EntityName}Service {
+    /**
+     * Create a new {entityName}
+     */
+    create{EntityName}(input: ICreate{EntityName}Input): Promise<I{EntityName}Model>;
+
+    /**
+     * Update an existing {entityName}
+     */
+    update{EntityName}(
+        tenantId: string,
+        id: string,
+        update: IUpdate{EntityName}Input,
+    ): Promise<I{EntityName}Model>;
+
+    /**
+     * Get a specific {entityName}
+     */
+    get{EntityName}(tenantId: string, id: string): Promise<I{EntityName}Model | null>;
+
+    /**
+     * Get all {entityName} for a tenant with optional filtering
+     */
+    get{EntityNamePlural}(filter: I{EntityName}Filter): Promise<I{EntityName}Model[]>;
+
+    /**
+     * Delete a {entityName}
+     */
+    delete{EntityName}(tenantId: string, id: string, deletedBy: string): Promise<boolean>;
+}
+```
+
+### 5. Repository Templates
+
+**Location**: `packages-modules/{module}/server/src/templates/repositories/{EntityName}Repository.ts.template`
+
+```typescript
+import { ObjectId } from 'mongodb';
+import {
+    I{EntityName}Model,
+} from 'common/server';
+import {
+    ICreate{EntityName}Input,
+    IUpdate{EntityName}Input,
+    I{EntityName}Filter,
+} from '../services/{EntityName}Service';
+
+/**
+ * Repository interface for {entityName} data access layer
+ */
+export interface I{EntityName}Repository {
+    /**
+     * Create a new {entityName} record
+     */
+    create(input: ICreate{EntityName}Input): Promise<I{EntityName}Model>;
+
+    /**
+     * Update an existing {entityName}
+     */
+    updateById(
+        tenantId: string,
+        id: string,
+        update: IUpdate{EntityName}Input,
+    ): Promise<I{EntityName}Model | null>;
+
+    /**
+     * Find a specific {entityName}
+     */
+    findById(tenantId: string, id: string): Promise<I{EntityName}Model | null>;
+
+    /**
+     * Find {entityName} by criteria
+     */
+    findByCriteria(filter: I{EntityName}Filter): Promise<I{EntityName}Model[]>;
+
+    /**
+     * Check if {entityName} exists
+     */
+    exists(tenantId: string, {keyField}: string): Promise<boolean>;
+
+    /**
+     * Delete a {entityName}
+     */
+    deleteById(tenantId: string, id: string): Promise<boolean>;
+
+    /**
+     * Count {entityName} by criteria
+     */
+    countByCriteria(filter: I{EntityName}Filter): Promise<number>;
+}
+```
+
+### 6. Event Types (if needed)
+
+**Location**: `packages-modules/{module}/server/src/graphql/schemas/service.graphql`
+
+```graphql
+# Add to existing service enum
+extend enum MoleculerServiceName {
+    {EntityName}Service
+}
+
+enum {EntityName}ServiceAction {
+    On{EntityName}Created
+    On{EntityName}Updated
+    On{EntityName}Deleted
+}
+
+# Event Types (no @entity directive for events)
+type {EntityName}CreatedEvent {
+    {entityName}Id: String!
+    tenantId: String!
+    createdBy: String!
+    createdAt: String!
+    {relevantField}: String!
+}
+
+type {EntityName}UpdatedEvent {
+    {entityName}Id: String!
+    tenantId: String!
+    updatedBy: String!
+    updatedAt: String!
+    changes: JSON!
+}
+
+type {EntityName}DeletedEvent {
+    {entityName}Id: String!
+    tenantId: String!
+    deletedBy: String!
+    deletedAt: String!
+}
+```
+
+### 7. Template Configuration
+
+**Location**: `packages-modules/{module}/server/package.json`
+
+```json
+{
+    "cdecode": {
+        "templates": {
+            "services": {
+                "src": "src/templates/services",
+                "dest": "../../packages/common/src/services"
+            },
+            "repositories": {
+                "src": "src/templates/repositories",
+                "dest": "../../packages/common/src/repositories"
+            },
+            "constants": {
+                "src": "src/templates/constants",
+                "dest": "../../packages/common/src/constants"
+            }
+        }
+    }
+}
+```
+
+### 8. SERVER_TYPES Constants
+
+**Location**: `packages/common/src/constants/SERVER_TYPES.ts` (add to existing)
+
+```typescript
+export const SERVER_TYPES = {
+    // ... existing types
+    I{EntityName}Service: Symbol.for('I{EntityName}Service'),
+    I{EntityName}Repository: Symbol.for('I{EntityName}Repository'),
+    I{EntityName}MongoConnection: Symbol.for('I{EntityName}MongoConnection'),
+} as const;
+```
+
+### 9. Service Implementation
+
+**Location**: `packages-modules/{module}/server/src/services/{entity}-service.ts`
+
+```typescript
+import { inject, injectable } from 'inversify';
+import { CdmLogger } from '@cdm-logger/core';
+import { ServiceBroker } from 'moleculer';
+import { CommonType } from '@common-stack/core';
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import {
+    SERVER_TYPES,
+    I{EntityName}Service,
+    I{EntityName}Repository,
+    I{EntityName}Model,
+    ICreate{EntityName}Input,
+    IUpdate{EntityName}Input,
+    I{EntityName}Filter,
+    // Event types if needed
+    I{EntityName}CreatedEvent,
+    I{EntityName}UpdatedEvent,
+    I{EntityName}DeletedEvent,
+} from 'common/server';
+
+@injectable()
+export class {EntityName}Service implements I{EntityName}Service, Disposable {
+    // Event emitters (if needed)
+    protected readonly on{EntityName}Created = new Emitter<I{EntityName}CreatedEvent>();
+    protected readonly on{EntityName}Updated = new Emitter<I{EntityName}UpdatedEvent>();
+    protected readonly on{EntityName}Deleted = new Emitter<I{EntityName}DeletedEvent>();
+
+    protected readonly toDispose = new DisposableCollection(
+        this.on{EntityName}Created,
+        this.on{EntityName}Updated,
+        this.on{EntityName}Deleted,
+    );
+
+    private logger: CdmLogger.ILogger;
+
+    constructor(
+        @inject(SERVER_TYPES.I{EntityName}Repository)
+        private {entityName}Repository: I{EntityName}Repository,
+
+        @inject(CommonType.MOLECULER_BROKER)
+        protected broker: ServiceBroker,
+
+        @inject(CommonType.LOGGER)
+        logger: CdmLogger.ILogger,
+    ) {
+        this.logger = logger.child({ className: {EntityName}Service.name });
+    }
+
+    public dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    public async create{EntityName}(input: ICreate{EntityName}Input): Promise<AsDomainType<I{EntityName}Model>> {
+        this.logger.info(`Creating {entityName} for tenant ${input.tenantId}`);
+
+        // Validation logic here
+
+        const {entityName} = await this.{entityName}Repository.create(input);
+
+        // Fire creation event
+        const event: I{EntityName}CreatedEvent = {
+            {entityName}Id: {entityName}.id,
+            tenantId: input.tenantId,
+            createdBy: input.createdBy,
+            createdAt: new Date().toISOString(),
+            {relevantField}: {entityName}.{relevantField},
+        };
+
+        this.on{EntityName}Created.fire(event);
+
+        this.logger.info(`Successfully created {entityName} ${{entityName}.id}`);
+
+        // CRITICAL: Cast repository result to AsDomainType for GraphQL compatibility
+        return {entityName} as unknown as AsDomainType<I{EntityName}Model>;
+    }
+
+    public async update{EntityName}(
+        tenantId: string,
+        id: string,
+        update: IUpdate{EntityName}Input,
+    ): Promise<AsDomainType<I{EntityName}Model>> {
+        this.logger.info(`Updating {entityName} ${id} for tenant ${tenantId}`);
+
+        const updated{EntityName} = await this.{entityName}Repository.updateById(tenantId, id, update);
+
+        if (!updated{EntityName}) {
+            throw new Error(`{EntityName} ${id} not found for tenant ${tenantId}`);
+        }
+
+        // Fire update event
+        const event: I{EntityName}UpdatedEvent = {
+            {entityName}Id: id,
+            tenantId,
+            updatedBy: update.updatedBy || 'system',
+            updatedAt: new Date().toISOString(),
+            changes: update,
+        };
+
+        this.on{EntityName}Updated.fire(event);
+
+        // CRITICAL: Cast repository result to AsDomainType for GraphQL compatibility
+        return updated{EntityName} as unknown as AsDomainType<I{EntityName}Model>;
+    }
+
+    public async get{EntityName}(tenantId: string, id: string): Promise<I{EntityName}Model | null> {
+        return this.{entityName}Repository.findById(tenantId, id);
+    }
+
+    public async get{EntityNamePlural}(filter: I{EntityName}Filter): Promise<I{EntityName}Model[]> {
+        return this.{entityName}Repository.findByCriteria(filter);
+    }
+
+    public async delete{EntityName}(tenantId: string, id: string, deletedBy: string): Promise<boolean> {
+        this.logger.info(`Deleting {entityName} ${id} for tenant ${tenantId}`);
+
+        const {entityName} = await this.get{EntityName}(tenantId, id);
+        if (!{entityName}) {
+            throw new Error(`{EntityName} ${id} not found for tenant ${tenantId}`);
+        }
+
+        const deleted = await this.{entityName}Repository.deleteById(tenantId, id);
+
+        if (deleted) {
+            // Fire deletion event
+            const event: I{EntityName}DeletedEvent = {
+                {entityName}Id: id,
+                tenantId,
+                deletedBy,
+                deletedAt: new Date().toISOString(),
+            };
+
+            this.on{EntityName}Deleted.fire(event);
+            this.logger.info(`Successfully deleted {entityName} ${id}`);
+        }
+
+        return deleted;
+    }
+}
+```
+
+### 10. Container Module
+
+**Location**: `packages-modules/{module}/server/src/containers/module.ts`
+
+```typescript
+import { ContainerModule, interfaces } from 'inversify';
+import {
+    SERVER_TYPES,
+    I{EntityName}Service,
+    I{EntityName}Repository
+} from 'common/server';
+import { {EntityName}Service } from '../services/{entity}-service';
+import { {EntityName}ServiceExt } from '../services/{entity}-service-ext';
+import { {EntityName}Repository } from '../store/repositories/{entity}-repository';
+
+export const {module}Module: (settings: any) => interfaces.ContainerModule = (settings: any) =>
+    new ContainerModule((bind: interfaces.Bind) => {
+        bind(SERVER_TYPES.I{EntityName}MongoConnection).toConstantValue(settings.mongoConnection);
+
+        // {EntityName} Service
+        bind<I{EntityName}Service>(SERVER_TYPES.I{EntityName}Service)
+            .to({EntityName}ServiceExt)
+            .inSingletonScope()
+            .whenTargetIsDefault();
+
+        // {EntityName} Repository
+        bind<I{EntityName}Repository>(SERVER_TYPES.I{EntityName}Repository)
+            .to({EntityName}Repository as any)
+            .inSingletonScope()
+            .whenTargetIsDefault();
+    });
+```
+
+## 🔄 Build Process
+
+### 1. Template Generation
+
+```bash
+cd /path/to/workspace
+yarn regenerateGraphql
+```
+
+### 2. GraphQL Code Generation
+
+```bash
+yarn generateGraphql
+```
+
+### 3. Verification Steps
+
+1. Check generated types in `packages/common/src/generated/generated-models.ts`
+2. Verify interfaces in `packages/common/src/services/`
+3. Verify interfaces in `packages/common/src/repositories/`
+4. Check constants in `packages/common/src/constants/`
+
+## 🎯 Key Patterns and Principles
+
+### GraphQL Schema Design
+
+- **Entity Types**: Use `@entity` for database-mapped types
+- **Object References**: Use `@column(overrideType: "ObjectId")` for database relations
+- **Date Fields**: Use `@column(overrideType: "Date")` for timestamps
+- **Embedded Types**: Use `@embedded` for nested objects, `@entity(embedded: true)` for the type definition
+- **Events**: Never use `@entity` directive for event types
+- **API vs Storage**: Use human-readable IDs in API (`extensionID: String!`) but store as ObjectId references (`extension: ObjectId`)
+
+### Service Layer Architecture
+
+- **Interface First**: Always define service interfaces in templates
+- **Repository Pattern**: Services depend on repository interfaces, not implementations
+- **Event Driven**: Services emit events for important operations
+- **Validation**: Services handle business logic and validation
+- **Error Handling**: Services throw meaningful errors with context
+
+### Database Design
+
+- **Collection Naming**: Use `{module}_{entity_name}` pattern
+- **Indexes**: Always index tenant + key fields
+- **References**: Use ObjectId references with proper ref
+- **Timestamps**: Use mongoose timestamps option
+- **Virtuals**: Add `id` virtual for GraphQL compatibility
+
+### Template System
+
+- **Separation of Concerns**: Services define business interfaces, repositories define data access
+- **Code Generation**: Use templates to generate interfaces in common package
+- **Type Safety**: Generated types ensure consistency between GraphQL and TypeScript
+- **Reusability**: Templates create reusable patterns across all modules
+
+## 🚀 Usage Example
+
+To create a new "ProjectTask" service in the "project-mgmt" module:
+
+1. Replace `{EntityName}` with `ProjectTask`
+2. Replace `{entityName}` with `projectTask`
+3. Replace `{entityNamePlural}` with `projectTasks`
+4. Replace `{module}` with `project-mgmt`
+5. Replace `{entity}` with `project-task`
+6. Replace `{keyField}` with appropriate unique field (e.g., `taskId`)
+7. Replace `{RelatedEntity}` with related entities (e.g., `Project`)
+8. Follow all steps in the checklist
+
+This template ensures consistency, type safety, and follows established patterns across the entire adminIde-stack architecture.