@breadstone/archipel-mcp 0.0.21 → 0.0.22

package/src/knowledge/modulePattern.js

@@ -1,283 +0,0 @@
-"use strict";
-/**
- * Static knowledge content for the Archipel dynamic module pattern.
- * Returned by the get-module-pattern tool.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODULE_PATTERN_WITH_CONTEXT = exports.MODULE_PATTERN_KNOWLEDGE = void 0;
-exports.MODULE_PATTERN_KNOWLEDGE = `# Archipel Dynamic Module Pattern
-
-## Overview
-
-Archipel platform libraries use **NestJS dynamic modules** with a \`register()\` factory
-method and **port/adapter dependency inversion**. Each library defines abstract port
-classes. The consuming application provides concrete implementations at registration time.
-
-This pattern keeps platform libraries free of product-specific logic while allowing
-full customization through dependency injection.
-
-## Pattern Structure
-
-### 1. Abstract Port (Contract)
-
-\`\`\`typescript
-// contracts/FeatureAccessPort.ts
-
-export abstract class FeatureAccessPort {
-
-  public abstract checkAccess(userId: string, featureKey: string): Promise<IFeatureAccessResult>;
-
-  public abstract recordUsage(userId: string, featureKey: string): Promise<void>;
-
-}
-\`\`\`
-
-Ports are **abstract classes** (not interfaces) so they can serve as NestJS injection tokens.
-
-### 2. Options Interface
-
-\`\`\`typescript
-// interfaces/IPaymentModuleOptions.ts
-
-export interface IPaymentModuleOptions {
-  /**
-   * Concrete implementation of the FeatureAccessPort.
-   */
-  featureAccess?: Type<FeatureAccessPort>;
-
-  /**
-   * When true the module is registered globally.
-   */
-  isGlobal?: boolean;
-}
-\`\`\`
-
-### 3. Dynamic Module with register()
-
-\`\`\`typescript
-// PaymentModule.ts
-import { ConfigModule } from '@breadstone/archipel-platform-core';
-import { type DynamicModule, Module, type Type } from '@nestjs/common';
-
-@Module({})
-export class PaymentModule {
-
-  public static register(options?: IPaymentModuleOptions): DynamicModule {
-    const providers = [StripeClient, FeatureGuard, FeatureUsageInterceptor];
-
-    if (options?.featureAccess) {
-      providers.push({
-        provide: FeatureAccessPort,
-        useClass: options.featureAccess,
-      } as never);
-    }
-
-    return {
-      global: options?.isGlobal ?? false,
-      module: PaymentModule,
-      imports: [ConfigModule.register('platform-payments', PLATFORM_PAYMENTS_CONFIG_ENTRIES)],
-      providers: providers,
-      exports: [StripeClient, FeatureGuard, FeatureUsageInterceptor],
-    };
-  }
-
-}
-\`\`\`
-
-### 4. Consumer Registration
-
-\`\`\`typescript
-// In the consuming application:
-@Module({
-  imports: [
-    PaymentModule.register({
-      featureAccess: MyFeatureAccessAdapter,
-      isGlobal: true,
-    }),
-  ],
-})
-export class AppModule {}
-\`\`\`
-
-## Variants in the Codebase
-
-### Simple: PaymentModule
-
-- 1 optional port (\`featureAccess\`)
-- Optional \`isGlobal\` flag
-- Config via \`ConfigModule.register()\`
-
-### Complex: AuthModule
-
-- 4 required ports (\`authSubject\`, \`mfaSubject\`, \`sessionPersistence\`, \`verificationSubject\`)
-- 2 optional ports (\`socialAuth\`, \`tokenEnricher\`)
-- Conditional strategy registration (social OAuth only when \`socialAuth\` provided)
-- Imports: PassportModule, JwtModule, MappingModule, EventModule, IdentifierModule
-- Middleware configuration via \`configure(consumer)\`
-
-### Provider-based: BlobModule
-
-- Uses \`forRoot()\` instead of \`register()\` (global by default)
-- Discriminated union for provider selection: \`{ kind: 'Vercel' }\` or \`{ kind: 'Custom', useClass: ... }\`
-- Optional persistence ports (\`objectPersistence\`, \`variantPersistence\`)
-
-### Infrastructure: DatabaseModule
-
-- Both \`forRoot()\` (global) and \`register()\` (scoped) variants
-- Factory provider for PrismaService with extensions
-- Health indicator bootstrapping
-
-### Async: McpModule
-
-- \`register(options)\` for synchronous configuration
-- \`registerAsync({ useFactory, inject })\` for async (e.g., reading config at runtime)
-- \`registerAsync({ useClass })\` for factory class pattern
-- \`registerAsync({ useExisting })\` for reusing an existing factory
-
-## ConfigModule Integration
-
-Every library module imports \`ConfigModule.register()\` to declare its configuration
-dependencies:
-
-\`\`\`typescript
-imports: [ConfigModule.register('platform-payments', PLATFORM_PAYMENTS_CONFIG_ENTRIES)]
-\`\`\`
-
-This registers typed config keys into the global \`ConfigRegistry\` for validation
-and discovery.
-
-## MappingModule Integration
-
-Modules that need object mapping import \`MappingModule.withProfiles()\`:
-
-\`\`\`typescript
-imports: [MappingModule.withProfiles([SessionMappingProfile])]
-\`\`\`
-
-## Health Indicator Pattern
-
-Infrastructure modules (Database, Blob) register health indicators:
-
-\`\`\`typescript
-providers: [
-  BlobHealthIndicator,
-  {
-    provide: 'BLOB_HEALTH_INDICATOR_BOOTSTRAP',
-    useFactory: (orchestrator: HealthOrchestrator, indicator: BlobHealthIndicator) => {
-      orchestrator.registerIndicator(indicator);
-      return true;
-    },
-    inject: [HealthOrchestrator, BlobHealthIndicator],
-  },
-]
-\`\`\`
-
-## Rules
-
-1. **Ports are abstract classes** — not interfaces — so they work as DI tokens.
-2. **\`register()\` for stateless config**, \`registerAsync()\` when config depends on runtime values.
-3. **\`forRoot()\` for global singletons** (database, blob storage), \`register()\` for scoped modules.
-4. **Always import ConfigModule.register()** to declare environment dependencies.
-5. **Optional ports use conditional provider registration** (\`if (options?.port)\`).
-6. **Required ports are listed in the options interface** without optional markers.
-7. **Exports should list concrete services, guards, interceptors** — not internal implementation details.
-`;
-const MODULE_PATTERN_WITH_CONTEXT = (moduleName, ports) => `
-## Example: Dynamic Module "${moduleName}"
-
-With ports: ${ports.map((p) => `\`${p}\``).join(', ')}
-
-### Port Definitions
-
-${ports
-    .map((port) => `\`\`\`typescript
-// contracts/${port}.ts
-
-export abstract class ${port} {
-
-  // Define abstract methods for the port contract
-  public abstract execute(/* args */): Promise<void>;
-
-}
-\`\`\``)
-    .join('\n\n')}
-
-### Options Interface
-
-\`\`\`typescript
-// interfaces/I${moduleName}Options.ts
-import { Type } from '@nestjs/common';
-${ports.map((port) => `import { ${port} } from '../contracts/${port}';`).join('\n')}
-
-export interface I${moduleName}Options {
-${ports.map((port) => `  ${lowerFirstChar(port)}: Type<${port}>;`).join('\n')}
-  isGlobal?: boolean;
-}
-\`\`\`
-
-### Module Class
-
-\`\`\`typescript
-// ${moduleName}.ts
-import { ConfigModule } from '@breadstone/archipel-platform-core';
-import { type DynamicModule, Module, type Type } from '@nestjs/common';
-import { I${moduleName}Options } from './interfaces/I${moduleName}Options';
-${ports.map((port) => `import { ${port} } from './contracts/${port}';`).join('\n')}
-
-@Module({})
-export class ${moduleName} {
-
-  public static register(options: I${moduleName}Options): DynamicModule {
-    const portProviders = [
-${ports.map((port) => `      { provide: ${port}, useClass: options.${lowerFirstChar(port)} },`).join('\n')}
-    ];
-
-    return {
-      global: options.isGlobal ?? false,
-      module: ${moduleName},
-      imports: [
-        ConfigModule.register('${toKebabCase(moduleName)}', PLATFORM_${toUpperSnakeCase(moduleName)}_CONFIG_ENTRIES),
-      ],
-      providers: [
-        ...portProviders,
-        // Add services, guards, interceptors here
-      ],
-      exports: [
-        // Export public services, guards, interceptors
-      ],
-    };
-  }
-
-}
-\`\`\`
-
-### Consumer Usage
-
-\`\`\`typescript
-@Module({
-  imports: [
-    ${moduleName}.register({
-${ports.map((port) => `      ${lowerFirstChar(port)}: My${port}Adapter,`).join('\n')}
-    }),
-  ],
-})
-export class AppModule {}
-\`\`\`
-`;
-exports.MODULE_PATTERN_WITH_CONTEXT = MODULE_PATTERN_WITH_CONTEXT;
-function lowerFirstChar(str) {
-    return str.charAt(0).toLowerCase() + str.slice(1);
-}
-function toKebabCase(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .toLowerCase()
-        .replace(/module$/, '');
-}
-function toUpperSnakeCase(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, '$1_$2')
-        .toUpperCase()
-        .replace(/MODULE$/, '');
-}
-//# sourceMappingURL=modulePattern.js.map

package/src/knowledge/queryPattern.d.ts

@@ -1,6 +0,0 @@
-/**
- * Static knowledge content for the Archipel query pattern.
- * Returned by the get-query-pattern tool.
- */
-export declare const QUERY_PATTERN_KNOWLEDGE = "# Archipel Query Pattern (v1)\n\n## Overview\n\nIn Archipel, data access follows the **Repository + Query** pattern. Repositories never expose\nraw Prisma delegate methods to services. Instead, every data operation is wrapped in a\n**query factory function** that returns an `IRepositoryQuery` object. Services call\n`repository.execute(someQuery(...))` \u2014 never `repository.findFirst(...)` directly.\n\n## Core Interface\n\n```typescript\nexport interface IRepositoryQuery<TDelegate, TResult> {\n  readonly name: string;\n  run(model: TDelegate): Promise<TResult>;\n}\n```\n\n- `TDelegate` \u2014 the Prisma delegate type (e.g. `Prisma.UserDelegate`)\n- `TResult` \u2014 the query's return type\n- `name` \u2014 identifier used for logging and debugging\n\n## Factory Function\n\n```typescript\nimport { IRepositoryQuery } from '@breadstone/archipel-platform-database';\n\nexport function query<TDelegate, TResult>(\n  name: string,\n  run: (model: TDelegate) => Promise<TResult>,\n): IRepositoryQuery<TDelegate, TResult> {\n  return { name, run };\n}\n```\n\n## Type Extraction\n\n```typescript\nexport type QueryResultType<T> = T extends IRepositoryQuery<unknown, infer R> ? R : never;\n```\n\nUse this to derive the result type from a query factory without duplicating types:\n```typescript\ntype UserProfileResult = QueryResultType<ReturnType<typeof findUserProfileQuery>>;\n```\n\n## How to Write a Query\n\n### Step 1: Define the query factory function\n\nEach query is a **named function** that returns an `IRepositoryQuery`. The function may accept\nparameters \u2014 these become the query's runtime arguments.\n\n```typescript\nimport { Prisma } from '@prisma/client';\nimport { query } from '@breadstone/archipel-platform-database';\n\nexport function findUserByEmailQuery(email: string) {\n  return query<Prisma.UserDelegate, { id: string; email: string; name: string } | null>(\n    'findUserByEmail',\n    (model) =>\n      model.findFirst({\n        where: { email },\n        select: { id: true, email: true, name: true },\n      }),\n  );\n}\n```\n\n### Step 2: Call from a service via repository.execute()\n\n```typescript\n// In the service:\nconst user = await this._userRepository.execute(findUserByEmailQuery(email));\n```\n\n### Step 3: Extract result type if needed for mapping\n\n```typescript\ntype FindUserByEmailResult = QueryResultType<ReturnType<typeof findUserByEmailQuery>>;\n```\n\n## Transactional Queries\n\nFor operations that span multiple models, use `transactionalQuery`:\n\n```typescript\nimport { Prisma } from '@prisma/client';\nimport { transactionalQuery } from '@breadstone/archipel-platform-database';\n\nexport function createOrderWithItemsQuery(data: { userId: string; items: Array<{ productId: string; quantity: number }> }) {\n  return transactionalQuery<{ orderId: string }>(\n    'createOrderWithItems',\n    async (tx: Prisma.TransactionClient) => {\n      const order = await tx.order.create({\n        data: { userId: data.userId },\n        select: { id: true },\n      });\n\n      await tx.orderItem.createMany({\n        data: data.items.map((item) => ({\n          orderId: order.id,\n          productId: item.productId,\n          quantity: item.quantity,\n        })),\n      });\n\n      return { orderId: order.id };\n    },\n  );\n}\n```\n\nCalled via:\n```typescript\nconst result = await this._orderRepository.executeTransactional(\n  createOrderWithItemsQuery({ userId, items }),\n);\n```\n\n## Rules\n\n1. **Never call Prisma delegate methods directly from services.** Always go through `execute(query)`.\n2. **Always select only the fields you need.** Use `select` \u2014 never return full records.\n3. **Query names must be descriptive.** Use the pattern: `verbModelByConditionQuery`\n   (e.g. `findUserByEmailQuery`, `countOrdersByStatusQuery`, `updateUserNameQuery`).\n4. **One query per file** for non-trivial queries. Small related queries may share a file.\n5. **Type the result explicitly.** The second generic parameter of `query()` should be an inline\n   object type or a dedicated interface matching the `select` shape.\n6. **Each query factory is a standalone function** (not a class method). Import `query` from\n   `@breadstone/archipel-platform-database`.\n";
-export declare const QUERY_PATTERN_WITH_MODEL: (modelName: string, fields: string[]) => string;

package/src/knowledge/queryPattern.js

@@ -1,215 +0,0 @@
-"use strict";
-/**
- * Static knowledge content for the Archipel query pattern.
- * Returned by the get-query-pattern tool.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QUERY_PATTERN_WITH_MODEL = exports.QUERY_PATTERN_KNOWLEDGE = void 0;
-exports.QUERY_PATTERN_KNOWLEDGE = `# Archipel Query Pattern (v1)
-
-## Overview
-
-In Archipel, data access follows the **Repository + Query** pattern. Repositories never expose
-raw Prisma delegate methods to services. Instead, every data operation is wrapped in a
-**query factory function** that returns an \`IRepositoryQuery\` object. Services call
-\`repository.execute(someQuery(...))\` — never \`repository.findFirst(...)\` directly.
-
-## Core Interface
-
-\`\`\`typescript
-export interface IRepositoryQuery<TDelegate, TResult> {
-  readonly name: string;
-  run(model: TDelegate): Promise<TResult>;
-}
-\`\`\`
-
-- \`TDelegate\` — the Prisma delegate type (e.g. \`Prisma.UserDelegate\`)
-- \`TResult\` — the query's return type
-- \`name\` — identifier used for logging and debugging
-
-## Factory Function
-
-\`\`\`typescript
-import { IRepositoryQuery } from '@breadstone/archipel-platform-database';
-
-export function query<TDelegate, TResult>(
-  name: string,
-  run: (model: TDelegate) => Promise<TResult>,
-): IRepositoryQuery<TDelegate, TResult> {
-  return { name, run };
-}
-\`\`\`
-
-## Type Extraction
-
-\`\`\`typescript
-export type QueryResultType<T> = T extends IRepositoryQuery<unknown, infer R> ? R : never;
-\`\`\`
-
-Use this to derive the result type from a query factory without duplicating types:
-\`\`\`typescript
-type UserProfileResult = QueryResultType<ReturnType<typeof findUserProfileQuery>>;
-\`\`\`
-
-## How to Write a Query
-
-### Step 1: Define the query factory function
-
-Each query is a **named function** that returns an \`IRepositoryQuery\`. The function may accept
-parameters — these become the query's runtime arguments.
-
-\`\`\`typescript
-import { Prisma } from '@prisma/client';
-import { query } from '@breadstone/archipel-platform-database';
-
-export function findUserByEmailQuery(email: string) {
-  return query<Prisma.UserDelegate, { id: string; email: string; name: string } | null>(
-    'findUserByEmail',
-    (model) =>
-      model.findFirst({
-        where: { email },
-        select: { id: true, email: true, name: true },
-      }),
-  );
-}
-\`\`\`
-
-### Step 2: Call from a service via repository.execute()
-
-\`\`\`typescript
-// In the service:
-const user = await this._userRepository.execute(findUserByEmailQuery(email));
-\`\`\`
-
-### Step 3: Extract result type if needed for mapping
-
-\`\`\`typescript
-type FindUserByEmailResult = QueryResultType<ReturnType<typeof findUserByEmailQuery>>;
-\`\`\`
-
-## Transactional Queries
-
-For operations that span multiple models, use \`transactionalQuery\`:
-
-\`\`\`typescript
-import { Prisma } from '@prisma/client';
-import { transactionalQuery } from '@breadstone/archipel-platform-database';
-
-export function createOrderWithItemsQuery(data: { userId: string; items: Array<{ productId: string; quantity: number }> }) {
-  return transactionalQuery<{ orderId: string }>(
-    'createOrderWithItems',
-    async (tx: Prisma.TransactionClient) => {
-      const order = await tx.order.create({
-        data: { userId: data.userId },
-        select: { id: true },
-      });
-
-      await tx.orderItem.createMany({
-        data: data.items.map((item) => ({
-          orderId: order.id,
-          productId: item.productId,
-          quantity: item.quantity,
-        })),
-      });
-
-      return { orderId: order.id };
-    },
-  );
-}
-\`\`\`
-
-Called via:
-\`\`\`typescript
-const result = await this._orderRepository.executeTransactional(
-  createOrderWithItemsQuery({ userId, items }),
-);
-\`\`\`
-
-## Rules
-
-1. **Never call Prisma delegate methods directly from services.** Always go through \`execute(query)\`.
-2. **Always select only the fields you need.** Use \`select\` — never return full records.
-3. **Query names must be descriptive.** Use the pattern: \`verbModelByConditionQuery\`
-   (e.g. \`findUserByEmailQuery\`, \`countOrdersByStatusQuery\`, \`updateUserNameQuery\`).
-4. **One query per file** for non-trivial queries. Small related queries may share a file.
-5. **Type the result explicitly.** The second generic parameter of \`query()\` should be an inline
-   object type or a dedicated interface matching the \`select\` shape.
-6. **Each query factory is a standalone function** (not a class method). Import \`query\` from
-   \`@breadstone/archipel-platform-database\`.
-`;
-const QUERY_PATTERN_WITH_MODEL = (modelName, fields) => `
-## Example: Queries for \\"${modelName}\\"
-
-Given a Prisma model \`${modelName}\` with fields: ${fields.map((f) => `\`${f}\``).join(', ')}
-
-### findFirst query
-\`\`\`typescript
-import { Prisma } from '@prisma/client';
-import { query } from '@breadstone/archipel-platform-database';
-
-export function find${modelName}ByIdQuery(id: string) {
-  return query<Prisma.${modelName}Delegate, { ${fields.map((f) => `${f}: ${inferFieldType(f)}`).join('; ')} } | null>(
-    'find${modelName}ById',
-    (model) =>
-      model.findFirst({
-        where: { id },
-        select: { ${fields.map((f) => `${f}: true`).join(', ')} },
-      }),
-  );
-}
-\`\`\`
-
-### findMany query
-\`\`\`typescript
-export function findAll${modelName}sQuery(skip = 0, take = 20) {
-  return query<Prisma.${modelName}Delegate, Array<{ ${fields.map((f) => `${f}: ${inferFieldType(f)}`).join('; ')} }>>(
-    'findAll${modelName}s',
-    (model) =>
-      model.findMany({
-        skip,
-        take,
-        select: { ${fields.map((f) => `${f}: true`).join(', ')} },
-        orderBy: { ${fields.includes('createdAt') ? 'createdAt' : fields[0]}: 'desc' },
-      }),
-  );
-}
-\`\`\`
-
-### count query
-\`\`\`typescript
-export function count${modelName}sQuery() {
-  return query<Prisma.${modelName}Delegate, number>(
-    'count${modelName}s',
-    (model) => model.count(),
-  );
-}
-\`\`\`
-
-### Service usage
-\`\`\`typescript
-// In a service method:
-const item = await this._${lowerFirst(modelName)}Repository.execute(find${modelName}ByIdQuery(id));
-const items = await this._${lowerFirst(modelName)}Repository.execute(findAll${modelName}sQuery(0, 50));
-const total = await this._${lowerFirst(modelName)}Repository.execute(count${modelName}sQuery());
-\`\`\`
-`;
-exports.QUERY_PATTERN_WITH_MODEL = QUERY_PATTERN_WITH_MODEL;
-function inferFieldType(fieldName) {
-    if (fieldName === 'id')
-        return 'string';
-    if (fieldName.endsWith('Id'))
-        return 'string';
-    if (fieldName.endsWith('At') || fieldName === 'createdAt' || fieldName === 'updatedAt')
-        return 'Date';
-    if (fieldName.startsWith('is') || fieldName.startsWith('has'))
-        return 'boolean';
-    if (fieldName === 'count' || fieldName === 'quantity' || fieldName === 'amount' || fieldName === 'order')
-        return 'number';
-    if (fieldName === 'email' || fieldName === 'name' || fieldName === 'title' || fieldName === 'description')
-        return 'string';
-    return 'unknown';
-}
-function lowerFirst(str) {
-    return str.charAt(0).toLowerCase() + str.slice(1);
-}
-//# sourceMappingURL=queryPattern.js.map

package/src/knowledge/repositoryPattern.d.ts

@@ -1,6 +0,0 @@
-/**
- * Static knowledge content for the Archipel repository class pattern.
- * Returned by the get-repository-pattern tool.
- */
-export declare const REPOSITORY_PATTERN_KNOWLEDGE = "# Archipel Repository Pattern\n\n## Overview\n\nEvery Prisma model gets a dedicated **Repository class** extending `RepositoryBase`.\nRepositories are the ONLY code that touches Prisma delegates. Services never call\nPrisma directly \u2014 they call `repository.execute(someQuery(...))` or\n`repository.executeTransactional(someTxQuery(...))`.\n\n## RepositoryBase Signature\n\n```typescript\nimport { RepositoryBase } from '@breadstone/archipel-platform-database';\n\nexport abstract class RepositoryBase<\n  TDelegate extends Record<RepositoryOperations, (args: any) => Promise<any>>,\n  TArgs extends Record<RepositoryOperations, unknown>,\n  TReturn extends Record<RepositoryOperations, unknown>,\n  TEntity = unknown\n>\n```\n\n### Generic Parameters\n\n| Param | Purpose | Example |\n|-------|---------|---------|\n| `TDelegate` | Prisma delegate type from generated client | `Prisma.UserDelegate` |\n| `TArgs` | Argument shapes for each operation | `Prisma.UserFindManyArgs`, etc. |\n| `TReturn` | Return shapes for each operation | `User`, `User[]`, etc. |\n| `TEntity` | Domain entity interface (optional) | `IUserEntity` |\n\n### Helper Types\n\n```typescript\nimport { DelegateArgs, DelegateReturnTypes } from '@breadstone/archipel-platform-database';\n\n// These extract args and return types from a delegate automatically:\ntype UserArgs = DelegateArgs<Prisma.UserDelegate>;\ntype UserReturns = DelegateReturnTypes<Prisma.UserDelegate>;\n```\n\n## How to Create a Repository\n\n### Step 1: Create the repository class\n\n```typescript\n// repositories/UserRepository.ts\nimport { Injectable } from '@nestjs/common';\nimport { Prisma } from '@prisma/client';\nimport {\n  DatabaseService,\n  DelegateArgs,\n  DelegateReturnTypes,\n  RepositoryBase,\n} from '@breadstone/archipel-platform-database';\n\n@Injectable()\nexport class UserRepository extends RepositoryBase<\n  Prisma.UserDelegate,\n  DelegateArgs<Prisma.UserDelegate>,\n  DelegateReturnTypes<Prisma.UserDelegate>,\n  IUserEntity\n> {\n\n  // #region Ctor\n\n  public constructor(db: DatabaseService) {\n    super(db, db.client.user);\n  }\n\n  // #endregion\n\n}\n```\n\nThe constructor receives `DatabaseService` and passes both the service and the\nPrisma delegate (`db.client.user`) to the base class.\n\n### Step 2: Register as a provider in a module\n\n```typescript\n@Module({\n  imports: [DatabaseModule.register()],\n  providers: [UserRepository, UserService],\n  exports: [UserService],\n})\nexport class UserModule {}\n```\n\n### Step 3: Inject into a service\n\n```typescript\n@Injectable()\nexport class UserService {\n\n  // #region Fields\n\n  private readonly _userRepository: UserRepository;\n\n  // #endregion\n\n  // #region Ctor\n\n  public constructor(userRepository: UserRepository) {\n    this._userRepository = userRepository;\n  }\n\n  // #endregion\n\n  // #region Methods\n\n  public async findById(id: string): Promise<IUserEntity | null> {\n    return this._userRepository.execute(findUserByIdQuery(id));\n  }\n\n  public async findAll(skip = 0, take = 20): Promise<IUserEntity[]> {\n    return this._userRepository.execute(findAllUsersQuery(skip, take));\n  }\n\n  // #endregion\n\n}\n```\n\n## Key Methods on RepositoryBase\n\n### execute(query)\n\nPrimary method for data access. Delegates to a query object.\n\n```typescript\npublic execute<TResult>(query: IRepositoryQuery<TDelegate, TResult>): Promise<TResult>\n```\n\n### executeTransactional(query)\n\nFor multi-model operations within a transaction.\n\n```typescript\npublic executeTransactional<TResult>(query: ITransactionalRepositoryQuery<TResult>): Promise<TResult>\n```\n\n### Direct Methods (for legacy or internal use only)\n\nThe base class also exposes `findUnique`, `findMany`, `findFirst`, `create`,\n`createMany`, `update`, `updateMany`, `upsert`, `delete`, `deleteMany`,\n`aggregate`, `count`, `groupBy`, `merge`.\n\n**Important:** New code should use `execute(query)` exclusively.\nDirect method calls are available but violate the query pattern convention.\n\n### findMany with Pagination\n\n```typescript\n// Direct method (legacy)\nconst results = await this._repository.findMany(args, { page: 1, perPage: 20 });\n```\n\n## Error Handling\n\nAll Prisma errors are caught by the base class `tryCatch` wrapper and re-thrown\nas `RepositoryError`:\n\n- `PrismaClientKnownRequestError` \u2192 `RepositoryError` with code `'R_KNOWN'`\n- `PrismaClientUnknownRequestError` \u2192 `RepositoryError` with code `'R_UNKNOWN'`\n- Other errors are re-thrown unchanged\n\nThe global `RepositoryExceptionFilter` catches `RepositoryError` and returns\nHTTP 500 with a structured envelope.\n\n## Query Integration\n\nRepositories work with query factories from the query pattern:\n\n```typescript\n// queries/findUserByIdQuery.ts\nimport { Prisma } from '@prisma/client';\nimport { query } from '@breadstone/archipel-platform-database';\n\nexport function findUserByIdQuery(id: string) {\n  return query<Prisma.UserDelegate, IUserEntity | null>(\n    'findUserById',\n    (model) => model.findFirst({\n      where: { id },\n      select: { id: true, email: true, name: true, createdAt: true },\n    }),\n  );\n}\n\n// Service usage:\nconst user = await this._userRepository.execute(findUserByIdQuery(id));\n```\n\n## Rules\n\n1. **One repository per Prisma model** \u2014 e.g. `UserRepository`, `OrderRepository`.\n2. **Constructor receives `DatabaseService`** and passes the delegate via `db.client.<model>`.\n3. **Use `DelegateArgs` and `DelegateReturnTypes`** helper types for the RepositoryBase generics.\n4. **New code uses `execute(query)`** \u2014 never direct calls like `repository.findFirst()` from services.\n5. **Register as provider** in the feature module, import `DatabaseModule.register()`.\n6. **Repositories are `@Injectable()`** \u2014 they participate in NestJS DI.\n7. **Domain entity interface as fourth generic** (`TEntity`) is optional but recommended.\n";
-export declare const REPOSITORY_PATTERN_WITH_MODEL: (modelName: string, fields: string[]) => string;