@cdmbase/wiki-browser 12.0.18-alpha.10

package/lib/templates/content/docs/server-side/backend-coding.md

@@ -0,0 +1,839 @@
+# CDEBase GraphQL Development Guide
+
+## Introduction to Schema-First Development
+
+This guide outlines the complete workflow for developing GraphQL features in the CDEBase Account Module using a schema-first approach with GraphQL Code Generator (codegen). We'll follow the Organization entity as our example throughout each layer of implementation.
+
+## Table of Contents
+
+1. [Schema Definition](#1-schema-definition)
+2. [Type Generation](#2-type-generation)
+3. [Database Models](#3-database-models)
+4. [Repositories](#4-repositories)
+5. [Services](#5-services)
+6. [Templates & Interfaces](#6-templates--interfaces)
+7. [Dependency Injection](#7-dependency-injection)
+8. [Complete Example Walkthrough](#8-complete-example-walkthrough)
+
+## 1. Schema Definition
+
+Schema-first development starts with defining your GraphQL schema. This is the contract between your client and server.
+
+### Key Components in GraphQL Schemas
+
+- **Types:** Define the structure of your data
+- **Queries:** Read operations
+- **Mutations:** Write operations
+- **Interfaces:** Shared structures
+- **Enums:** Predefined sets of values
+
+### MongoDB-Specific Directives
+
+The CDEBase framework uses special directives for MongoDB schema generation:
+
+- \`@entity\`: Marks a type as a MongoDB collection
+- \`@entity(embedded: true)\`: Marks a type as an embedded document
+- \`@column\`: Marks a field as a MongoDB column
+- \`@column(overrideType: "type")\`: Specifies MongoDB type override
+
+### Example: Organization Schema
+
+```graphql
+"""
+Organization: A company or group with members and teams.
+"""
+type Organization @entity {
+    """
+    Unique identifier for the organization
+    """
+    id: ID! @id
+
+    """
+    Organization name (used as identifier)
+    """
+    name: String! @column
+
+    """
+    Display title
+    """
+    title: String @column
+
+    """
+    Organization description
+    """
+    description: String @column
+
+    # More fields...
+
+    """
+    Organization status
+    """
+    status: OrganizationStatus @column
+
+    members: [OrganizationMember] @column(overrideType: "ObjectId[]")
+
+    # More fields with MongoDB type overrides
+    createdAt: DateTime! @column(overrideType: "Date")
+    updatedAt: DateTime! @column(overrideType: "Date")
+}
+
+# Input types for operations
+input OrganizationCreateRequest {
+    name: String
+    title: String
+    description: String
+    # ...other fields
+}
+
+# Define queries and mutations
+extend type Query {
+    organizations: [Organization] @addAccountContext
+    getUserOrganizations(userId: String): [Organization] @addAccountContext
+    # ...other queries
+}
+
+extend type Mutation {
+    createOrganization(organization: OrganizationCreateRequest!): Organization @addAccountContext
+    removeOrganization(organization: OrganizationRemoveRequest!): Boolean @addAccountContext
+    # ...other mutations
+}
+```
+
+### Common MongoDB Type Overrides
+
+- \`ObjectId\`: \`@column(overrideType: "ObjectId")\`
+- \`Date\`: \`@column(overrideType: "Date")\`
+- \`Array of ObjectIds\`: \`@column(overrideType: "[ObjectId]")\`
+- \`Embedded documents\`: \`@column(overrideType: "[EmbeddedType]")\`
+- \`Any type\`: \`@column(overrideType: "any")\`
+
+## 2. Type Generation
+
+After defining your GraphQL schema, generate TypeScript types using GraphQL Code Generator.
+
+### Configuration in codegen.ts
+
+The project uses a configuration file at the root called \`codegen.ts\`:
+
+```typescript
+const config = {
+    overwrite: true,
+    schema: [
+        // Schema locations...
+        'packages-modules/account-api/server/src/**/*.graphql',
+        // More locations...
+    ],
+    generates: {
+        'packages/common/src/generated/generated-models.ts': {
+            // Configurations...
+            plugins: [
+                'typescript',
+                'typescript-operations',
+                'typescript-resolvers',
+                'typescript-mongodb', // MongoDB specific generation
+            ],
+            config: {
+                dbTypeSuffix: 'Model', // Adds 'Model' suffix to DB types
+                typesPrefix: 'I', // Adds 'I' prefix to interfaces
+                // More config options...
+            },
+        },
+    },
+};
+```
+
+### Running Type Generation
+
+```bash
+yarn generateGraphql
+```
+
+This generates TypeScript interfaces in \`packages/common/src/generated/generated-models.ts\`, which are then used throughout the application.
+
+### Generated Types for Organization
+
+```typescript
+// Generated from GraphQL schema
+export interface IOrganizationModel {
+    __typename?: 'Organization';
+    id: string;
+    name: string;
+    title?: Maybe<string>;
+    description?: Maybe<string>;
+    members?: Maybe<Array<Maybe<IOrganizationMemberModel>>>;
+    status?: Maybe<OrganizationStatus>;
+    createdAt: Date;
+    updatedAt: Date;
+    // Additional fields...
+}
+```
+
+## 3. Database Models
+
+With the generated types, create Mongoose models in \`store/models/\`.
+
+### Organization Model Example
+
+```typescript
+// packages-modules/account-api/server/src/store/models/organization-model.ts
+import { Schema, Connection } from 'mongoose';
+import { IOrganizationModel, OrganizationStatus } from 'common/server';
+
+const OrganizationSchema = new Schema<IOrganizationModel>({
+    name: { type: Schema.Types.String, unique: true, required: true, index: true },
+    title: { type: Schema.Types.String },
+    description: { type: Schema.Types.String },
+    members: [{ type: Schema.Types.ObjectId, ref: 'organizationMember' }],
+    createdAt: { type: Schema.Types.Date, default: Date.now },
+    updatedAt: { type: Schema.Types.Date, default: Date.now },
+    status: {
+        type: Schema.Types.String,
+        enum: Object.values(OrganizationStatus),
+        default: OrganizationStatus.Active,
+        index: true,
+    },
+    // Other fields...
+});
+
+// Add virtual property for 'id'
+OrganizationSchema.virtual('id').get(function () {
+    return (this as any)._id.toHexString();
+});
+
+// Configure JSON serialization
+OrganizationSchema.set('toJSON', { virtuals: true });
+OrganizationSchema.set('toObject', { virtuals: true });
+
+// Export a function that creates and returns the model
+export const OrganizationModelFunc = (db: Connection) => db.model('organization', OrganizationSchema);
+```
+
+### Key Points for Models
+
+1. Use the generated interfaces (\`IOrganizationModel\`) directly
+2. Define schema using Mongoose's \`Schema.Types.\*\` syntax
+3. Add virtual \`id\` property that maps to MongoDB's \`\_id\`
+4. Configure proper serialization with \`toJSON\` and \`toObject\`
+5. Export a function that takes a \`Connection\` and returns the compiled model
+
+## 4. Repositories
+
+Repositories handle data access logic and extend \`BaseRepository\` from \`@common-stack/store-mongo\`.
+
+### Repository Interface
+
+First, define the repository interface in \`templates/repositories/\`:
+
+```typescript
+// packages-modules/account-api/server/src/templates/repositories/OrganizationRepository.ts.template
+import {
+    ApplicationRoles,
+    IOrganizationCreateRequest,
+    IOrganizationModel,
+    IBaseMongoRepository,
+    // More imports...
+} from 'common/server';
+
+export interface IOrganizationRepository extends IBaseMongoRepository<IOrganizationModel> {
+    /**
+     * Creates a new organization
+     *
+     * @param {IOrganizationCreateRequest} organization - Organization creation parameters
+     * @returns {Promise<AsDomainType<IOrganizationModel>>} The created organization
+     */
+    createOrganization(organization: IOrganizationCreateRequest): Promise<AsDomainType<IOrganizationModel>>;
+
+    // Additional methods with detailed documentation...
+}
+```
+
+### Repository Implementation
+
+Then implement the repository in \`store/repositories/\`:
+
+```typescript
+// packages-modules/account-api/server/src/store/repositories/organization-repository.ts
+import { CdmLogger } from '@cdm-logger/core';
+import { inject, injectable, optional } from 'inversify';
+import { BaseMongoRepository } from '@common-stack/store-mongo';
+import mongoose, { Types } from 'mongoose';
+import {
+    IOrganizationRepository,
+    IOrganizationModel,
+    // More imports...
+} from 'common/server';
+import { OrganizationModelFunc } from '../models';
+
+@injectable()
+export class OrganizationRepository extends BaseMongoRepository<IOrganizationModel> implements IOrganizationRepository {
+    constructor(
+        @inject('MongoDBConnection')
+        db: mongoose.Connection,
+        @inject('Logger')
+        logger: CdmLogger.ILogger,
+        @inject('MongoOptions')
+        @optional()
+        options?: any,
+    ) {
+        super(OrganizationModelFunc, db, logger, options);
+        this.logger = logger.child({ className: 'OrganizationRepository' });
+    }
+
+    public async createOrganization(
+        newOrganization: IOrganizationCreateRequest,
+    ): Promise<AsDomainType<IOrganizationModel>> {
+        this.logger.trace('createOrganization with params (%j)', newOrganization);
+        const result = await this.model.create(newOrganization);
+        return (result as AsDomainType<IOrganizationModel>) || null;
+    }
+
+    // Implement additional methods...
+}
+```
+
+### Key Points for Repositories
+
+1. Use \`@injectable()\` to enable dependency injection
+2. Extend \`BaseMongoRepository<IOrganizationModel>\`
+3. Pass the model function to the super constructor
+4. Use appropriate logging with child logger
+5. Keep repositories focused on data access only (no business logic)
+6. Use \`AsDomainType<T>\` for return types to ensure proper typing
+
+## 5. Services
+
+Services contain business logic and orchestrate operations across repositories.
+
+### Service Interface
+
+First, define the service interface in \`templates/services/\`:
+
+```typescript
+// packages-modules/account-api/server/src/templates/services/OrganizationService.ts.template
+import {
+    IOrganizationModel,
+    IOrganizationCreateRequest,
+    IBaseService,
+    // More imports...
+} from 'common/server';
+
+export interface IOrganizationService extends IBaseService<IOrganizationModel> {
+    /**
+     * Creates a new organization
+     *
+     * @param organization - Organization creation request
+     * @param userContext - User context
+     * @returns The created organization
+     */
+    createOrganization(
+        organization: IOrganizationCreateRequest,
+        userContext?: IUserContext,
+    ): Promise<AsDomainType<IOrganizationModel>>;
+
+    // Additional methods with detailed documentation...
+}
+```
+
+### Service Implementation
+
+Then implement the service in \`services/\`:
+
+```typescript
+// packages-modules/account-api/server/src/services/OrganizationService.ts
+import { inject, injectable } from 'inversify';
+import { CdmLogger } from '@cdm-logger/core';
+import { BaseService2 } from '@common-stack/store-mongo';
+import {
+    IOrganizationService,
+    IOrganizationModel,
+    SERVER_TYPES,
+    // More imports...
+} from 'common/server';
+
+@injectable()
+export class OrganizationService2 extends BaseService2<IOrganizationModel> implements IOrganizationService {
+    private logger: CdmLogger.ILogger;
+
+    constructor(
+        @inject(SERVER_TYPES.IOrganizationRepository)
+        protected organizationRepository: IOrganizationRepository,
+        @inject(SERVER_TYPES.IAccountRepository)
+        protected accountRepository: IAccountRepository,
+        @inject('Logger')
+        logger: CdmLogger.ILogger,
+        // Other dependencies...
+    ) {
+        super(organizationRepository);
+        this.logger = logger.child({ className: 'OrganizationService2' });
+    }
+
+    public async createOrganization(
+        organization: IOrganizationCreateRequest,
+        userContext?: IUserContext,
+    ): Promise<AsDomainType<IOrganizationModel>> {
+        try {
+            if (!organization.name) {
+                throw new Error('Organization name is required');
+            }
+
+            const createdOrganization = await this.organizationRepository.createOrganization(organization);
+
+            if (!createdOrganization) {
+                throw new Error('Failed to create organization');
+            }
+
+            if (userContext) {
+                // Add the creating user as a member with Owner role
+                await this.addOrgMember(createdOrganization.name, userContext.accountId, [ApplicationRoles.Owner]);
+            }
+
+            // Fire creation event if needed
+            // this.onOrganizationCreated.fire({ ... });
+
+            return createdOrganization;
+        } catch (error) {
+            this.logger.error('Error creating organization: %o', error?.message);
+            throw error;
+        }
+    }
+
+    // Implement additional methods...
+}
+```
+
+### Key Points for Services
+
+1. Use \`@injectable()\` to enable dependency injection
+2. Extend \`BaseService2<IOrganizationModel>\`
+3. Inject repositories and other dependencies
+4. Include proper error handling and logging
+5. Implement business logic and orchestration between repositories
+6. Use \`try/catch\` blocks to handle errors gracefully
+
+## 6. Templates & Interfaces
+
+Templates define contracts for repositories and services, ensuring consistent implementation.
+
+### Organization Repository Template
+
+```typescript
+// packages-modules/account-api/server/src/templates/repositories/OrganizationRepository.ts.template
+export interface IOrganizationRepository extends IBaseMongoRepository<IOrganizationModel> {
+    // Method signatures with detailed documentation
+    createOrganization(organization: IOrganizationCreateRequest): Promise<AsDomainType<IOrganizationModel>>;
+    findOrganizationById(id: string): Promise<AsDomainType<IOrganizationModel> | null>;
+    // More methods...
+}
+```
+
+### Organization Service Template
+
+```typescript
+// packages-modules/account-api/server/src/templates/services/OrganizationService.ts.template
+export interface IOrganizationService extends IBaseService<IOrganizationModel> {
+    // Method signatures with detailed documentation
+    createOrganization(
+        organization: IOrganizationCreateRequest,
+        userContext?: IUserContext,
+    ): Promise<AsDomainType<IOrganizationModel>>;
+    // More methods...
+}
+```
+
+### Constants Template for Dependency Injection
+
+```typescript
+// packages-modules/account-api/server/src/templates/constants/SERVER_TYPES.ts.template
+export const SERVER_TYPES = {
+    IOrganizationRepository: Symbol('IOrganizationRepository'),
+    IOrganizationService: Symbol('IOrganizationService'),
+    // More symbols...
+};
+```
+
+## 7. Dependency Injection
+
+CDEBase uses InversifyJS for dependency injection.
+
+### Container Module
+
+```typescript
+// packages-modules/account-api/server/src/containers/module.ts
+import { ContainerModule, interfaces } from 'inversify';
+import { SERVER_TYPES } from 'common/server';
+import { OrganizationRepository } from '../store/repositories/organization-repository';
+import { OrganizationService2 } from '../services/OrganizationService';
+
+export const accountsModule = new ContainerModule((bind: interfaces.Bind) => {
+    // Bind repositories
+    bind(SERVER_TYPES.IOrganizationRepository).to(OrganizationRepository).inSingletonScope();
+
+    // Bind services
+    bind(SERVER_TYPES.IOrganizationService).to(OrganizationService2).inSingletonScope();
+
+    // More bindings...
+});
+```
+
+## 8. Complete Example Walkthrough
+
+Let's walk through creating a complete feature, from schema to service:
+
+### 1. Define the GraphQL Schema
+
+```graphql
+# packages-modules/account-api/server/src/graphql/schema/organization.graphql
+"""
+Organization: A company or group with members and teams.
+"""
+type Organization @entity {
+    id: ID! @id
+    name: String! @column
+    title: String @column
+    description: String @column
+    members: [OrganizationMember] @column(overrideType: "ObjectId[]")
+    createdAt: DateTime! @column(overrideType: "Date")
+    updatedAt: DateTime! @column(overrideType: "Date")
+    status: OrganizationStatus @column
+}
+
+input OrganizationCreateRequest {
+    name: String
+    title: String
+    description: String
+    # More fields...
+}
+
+extend type Query {
+    organizations: [Organization] @addAccountContext
+    getOrganizationDetail(where: OrgDetailWhere!): Organization!
+}
+
+extend type Mutation {
+    createOrganization(organization: OrganizationCreateRequest!): Organization @addAccountContext
+}
+```
+
+### 2. Generate TypeScript Types
+
+Run the code generator:
+
+```bash
+yarn generateGraphql
+```
+
+This generates TypeScript interfaces in \`packages/common/src/generated/generated-models.ts\`:
+
+```typescript
+export interface IOrganizationModel {
+    id: string;
+    name: string;
+    title?: Maybe<string>;
+    description?: Maybe<string>;
+    members?: Maybe<Array<Maybe<IOrganizationMemberModel>>>;
+    createdAt: Date;
+    updatedAt: Date;
+    status?: Maybe<OrganizationStatus>;
+}
+
+export interface IOrganizationCreateRequest {
+    name?: Maybe<string>;
+    title?: Maybe<string>;
+    description?: Maybe<string>;
+    // More fields...
+}
+```
+
+### 3. Create the Mongoose Model
+
+```typescript
+// packages-modules/account-api/server/src/store/models/organization-model.ts
+import { Schema, Connection } from 'mongoose';
+import { IOrganizationModel, OrganizationStatus } from 'common/server';
+
+const OrganizationSchema = new Schema<IOrganizationModel>({
+    name: { type: Schema.Types.String, unique: true, required: true, index: true },
+    title: { type: Schema.Types.String },
+    description: { type: Schema.Types.String },
+    members: [{ type: Schema.Types.ObjectId, ref: 'organizationMember' }],
+    createdAt: { type: Schema.Types.Date, default: Date.now },
+    updatedAt: { type: Schema.Types.Date, default: Date.now },
+    status: {
+        type: Schema.Types.String,
+        enum: Object.values(OrganizationStatus),
+        default: OrganizationStatus.Active,
+    },
+});
+
+OrganizationSchema.virtual('id').get(function () {
+    return (this as any)._id.toHexString();
+});
+
+OrganizationSchema.set('toJSON', { virtuals: true });
+OrganizationSchema.set('toObject', { virtuals: true });
+
+export const OrganizationModelFunc = (db: Connection) => db.model('organization', OrganizationSchema);
+```
+
+### 4. Define the Repository Interface
+
+```typescript
+// packages-modules/account-api/server/src/templates/repositories/OrganizationRepository.ts.template
+import { IOrganizationCreateRequest, IOrganizationModel, IBaseMongoRepository, AsDomainType } from 'common/server';
+
+export interface IOrganizationRepository extends IBaseMongoRepository<IOrganizationModel> {
+    createOrganization(organization: IOrganizationCreateRequest): Promise<AsDomainType<IOrganizationModel>>;
+    findOrganizationById(id: string): Promise<AsDomainType<IOrganizationModel> | null>;
+    findOrganizationByName(orgName: string): Promise<AsDomainType<IOrganizationModel> | null>;
+    // More methods...
+}
+```
+
+### 5. Implement the Repository
+
+```typescript
+// packages-modules/account-api/server/src/store/repositories/organization-repository.ts
+import { CdmLogger } from '@cdm-logger/core';
+import { inject, injectable, optional } from 'inversify';
+import { BaseMongoRepository } from '@common-stack/store-mongo';
+import mongoose, { Types } from 'mongoose';
+import { IOrganizationRepository, IOrganizationModel, IOrganizationCreateRequest, AsDomainType } from 'common/server';
+import { OrganizationModelFunc } from '../models';
+
+@injectable()
+export class OrganizationRepository extends BaseMongoRepository<IOrganizationModel> implements IOrganizationRepository {
+    constructor(
+        @inject('MongoDBConnection')
+        db: mongoose.Connection,
+        @inject('Logger')
+        logger: CdmLogger.ILogger,
+        @inject('MongoOptions')
+        @optional()
+        options?: any,
+    ) {
+        super(OrganizationModelFunc, db, logger, options);
+        this.logger = logger.child({ className: 'OrganizationRepository' });
+    }
+
+    public async createOrganization(
+        newOrganization: IOrganizationCreateRequest,
+    ): Promise<AsDomainType<IOrganizationModel>> {
+        this.logger.trace('createOrganization with params (%j)', newOrganization);
+        const result = await this.model.create(newOrganization);
+        return (result as AsDomainType<IOrganizationModel>) || null;
+    }
+
+    public async findOrganizationByName(orgName: string) {
+        const result = await this.model.findOne({ name: orgName }).exec();
+        return result?.toObject<AsDomainType<IOrganizationModel>>() || null;
+    }
+
+    public async findOrganizationById(id: string) {
+        try {
+            if (!Types.ObjectId.isValid(id)) {
+                throw new Error('Invalid organization ID format');
+            }
+            const objectId = new Types.ObjectId(id);
+            const result = await this.model.findById(objectId).exec();
+            return (result as AsDomainType<IOrganizationModel>) || null;
+        } catch (error) {
+            this.logger.error('Error finding organization by ID:', error);
+            throw error;
+        }
+    }
+
+    // Implement additional methods...
+}
+```
+
+### 6. Define the Service Interface
+
+```typescript
+// packages-modules/account-api/server/src/templates/services/OrganizationService.ts.template
+import {
+    IOrganizationModel,
+    IOrganizationCreateRequest,
+    IBaseService,
+    IUserContext,
+    AsDomainType,
+} from 'common/server';
+
+export interface IOrganizationService extends IBaseService<IOrganizationModel> {
+    createOrganization(
+        organization: IOrganizationCreateRequest,
+        userContext?: IUserContext,
+    ): Promise<AsDomainType<IOrganizationModel>>;
+
+    getOrganization(id: string): Promise<AsDomainType<IOrganizationModel>>;
+    getOrganizationByName(name: string): Promise<AsDomainType<IOrganizationModel> | null>;
+    // More methods...
+}
+```
+
+### 7. Implement the Service
+
+```typescript
+// packages-modules/account-api/server/src/services/OrganizationService.ts
+import { inject, injectable } from 'inversify';
+import { CdmLogger } from '@cdm-logger/core';
+import { BaseService2 } from '@common-stack/store-mongo';
+import {
+    IOrganizationService,
+    IOrganizationModel,
+    IOrganizationCreateRequest,
+    IUserContext,
+    SERVER_TYPES,
+    IOrganizationRepository,
+    AsDomainType,
+    ApplicationRoles,
+} from 'common/server';
+
+@injectable()
+export class OrganizationService2 extends BaseService2<IOrganizationModel> implements IOrganizationService {
+    private logger: CdmLogger.ILogger;
+
+    constructor(
+        @inject(SERVER_TYPES.IOrganizationRepository)
+        protected organizationRepository: IOrganizationRepository,
+        @inject('Logger')
+        logger: CdmLogger.ILogger,
+    ) {
+        super(organizationRepository);
+        this.logger = logger.child({ className: 'OrganizationService2' });
+    }
+
+    public async createOrganization(
+        organization: IOrganizationCreateRequest,
+        userContext?: IUserContext,
+    ): Promise<AsDomainType<IOrganizationModel>> {
+        try {
+            if (!organization.name) {
+                throw new Error('Organization name is required');
+            }
+
+            const createdOrganization = await this.organizationRepository.createOrganization(organization);
+
+            if (!createdOrganization) {
+                throw new Error('Failed to create organization');
+            }
+
+            if (userContext) {
+                // Add the creating user as a member with Owner role
+                await this.addOrgMember(createdOrganization.name, userContext.accountId, [ApplicationRoles.Owner]);
+            }
+
+            return createdOrganization;
+        } catch (error) {
+            this.logger.error('Error creating organization: %o', error?.message);
+            throw error;
+        }
+    }
+
+    public async getOrganization(id: string): Promise<AsDomainType<IOrganizationModel>> {
+        try {
+            const organization = await this.organizationRepository.findOrganizationById(id);
+
+            if (!organization) {
+                throw new Error(\`Organization with ID \${id} not found\`);
+            }
+
+            return organization;
+        } catch (error) {
+            this.logger.error('Error getting organization: %o', error);
+            throw error;
+        }
+    }
+
+    public async getOrganizationByName(name: string): Promise<AsDomainType<IOrganizationModel> | null> {
+        try {
+            if (!name) {
+                this.logger.warn('Empty organization name provided');
+                return null;
+            }
+
+            return await this.organizationRepository.findOrganizationByName(name);
+        } catch (error) {
+            this.logger.error('Error getting organization by name: %o', error);
+            return null;
+        }
+    }
+
+    // Implement additional methods...
+}
+```
+
+### 8. Register in the Dependency Injection Container
+
+```typescript
+// packages-modules/account-api/server/src/containers/module.ts
+import { ContainerModule, interfaces } from 'inversify';
+import { SERVER_TYPES } from 'common/server';
+import { OrganizationRepository } from '../store/repositories/organization-repository';
+import { OrganizationService2 } from '../services/OrganizationService';
+
+export const accountsModule = new ContainerModule((bind: interfaces.Bind) => {
+    // Bind repositories
+    bind(SERVER_TYPES.IOrganizationRepository).to(OrganizationRepository).inSingletonScope();
+
+    // Bind services
+    bind(SERVER_TYPES.IOrganizationService).to(OrganizationService2).inSingletonScope();
+});
+```
+
+### 9. Create GraphQL Resolvers
+
+```typescript
+// packages-modules/account-api/server/src/graphql/resolvers/organization-resolver.ts
+import { IResolvers } from 'common/server';
+
+export const resolvers: IResolvers = {
+    Query: {
+        organizations: async (_, args, context) => {
+            return context.organizationService.getAll();
+        },
+        getOrganizationDetail: async (_, { where }, context) => {
+            if (where.id) {
+                return context.organizationService.getOrganization(where.id);
+            } else if (where.name) {
+                const org = await context.organizationService.getOrganizationByName(where.name);
+                if (!org) {
+                    throw new Error(\`Organization \${where.name} not found\`);
+                }
+                return org;
+            }
+            throw new Error('Either id or name must be provided');
+        },
+    },
+    Mutation: {
+        createOrganization: async (_, { organization }, context) => {
+            return context.organizationService.createOrganization(
+                organization,
+                context.userContext
+            );
+        },
+    },
+};
+```
+
+## Conclusion
+
+Following this schema-first approach with GraphQL and codegen streamlines your development process in the CDEBase Account Module:
+
+1. Define GraphQL schema with MongoDB directives
+2. Generate TypeScript types with \`yarn generateGraphql\`
+3. Create Mongoose models using the generated interfaces
+4. Define repository interfaces in templates
+5. Implement repositories extending BaseMongoRepository
+6. Define service interfaces in templates
+7. Implement services extending BaseService
+8. Register in the dependency injection container
+9. Create GraphQL resolvers that use your services
+
+This approach ensures type safety throughout your application, from GraphQL schemas to MongoDB models to service implementations, maintaining a consistent contract between your API and data layers.`;
+
+      // Create blob and download
+      const blob = new Blob([markdownContent], { type: 'text/markdown' });
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download =