@nestjs-odata/typeorm 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,705 @@
+import { IncomingMessage } from "http";
+import { DataSource, EntityManager, EntityMetadata, ObjectLiteral, Repository, SelectQueryBuilder } from "typeorm";
+import { ApplyNode, BatchResponsePart, BinaryExprNode, EdmEntityConfig, EdmEntityType, EdmRegistry, EntityClass, FilterNode, FilterVisitor, FunctionCallNode, IETagProvider, IEdmDeriver, IQueryTranslator, ISearchProvider, LambdaExprNode, LiteralNode, ODataModuleOptions, ODataModuleResolvedOptions, ODataQuery, ODataQueryResult, OrderByItem, PropertyAccessNode, SearchNode, SelectNode, UnaryExprNode, UnmappedTypeStrategy } from "@nestjs-odata/core";
+import { DynamicModule, OnModuleInit } from "@nestjs/common";
+import { EntityClassOrSchema } from "@nestjs/typeorm/dist/interfaces/entity-class-or-schema.type.js";
+
+//#region src/batch/batch-controller.d.ts
+/**
+ * Minimal interface for the subset of Express Request used by BatchController.
+ * Avoids a direct dependency on @types/express in the typeorm adapter package.
+ */
+interface BatchRequest extends IncomingMessage {
+  body?: unknown;
+  rawBody?: Buffer | string;
+  headers: Record<string, string | string[] | undefined>;
+}
+/**
+ * Minimal interface for the subset of Express Response used by BatchController.
+ */
+interface BatchResponse {
+  status(code: number): this;
+  set(field: string, value: string): this;
+  send(body: string): this;
+  json(body: unknown): this;
+}
+/**
+ * BatchController handles POST /$batch requests.
+ *
+ * The service root prefix is set dynamically when registering this controller
+ * in ODataTypeOrmModule.forFeature().
+ */
+declare class BatchController {
+  private readonly dataSource;
+  private readonly edmRegistry;
+  private readonly options;
+  private readonly entityClasses;
+  constructor(dataSource: DataSource, edmRegistry: EdmRegistry, options: ODataModuleResolvedOptions, entityClasses: EntityClass[]);
+  /**
+   * POST {serviceRoot}/$batch
+   *
+   * Reads raw body (must be pre-configured with body-parser for text/plain or rawBody),
+   * parses multipart/mixed, dispatches sub-requests, builds multipart response.
+   */
+  handleBatch(req: BatchRequest, res: BatchResponse): Promise<void>;
+  /**
+   * Extract the raw body string from the request.
+   *
+   * Tries multiple strategies in order:
+   *   1. req.body as string (if a text/plain body parser ran first)
+   *   2. req.rawBody Buffer (NestJS rawBody: true option)
+   *   3. Read directly from the Node.js request stream (multipart/mixed fallback)
+   *      This works because $batch sends multipart/mixed which no standard body
+   *      parser processes, leaving the stream unconsumed.
+   */
+  private extractRawBody;
+  /**
+   * Dispatch a single individual request (outside a changeset).
+   * Failures are caught and returned as per-operation error responses (BATCH-03).
+   */
+  private dispatchIndividualRequest;
+  /**
+   * Execute all operations in a changeset within a single QueryRunner transaction.
+   * If any operation fails, all are rolled back (BATCH-02).
+   *
+   * Per D-02: full changeset rollback on any failure.
+   * Per WRITE-03 / T-10-08: contentIdMap is local to each changeset call — never leaks across changesets.
+   */
+  private executeChangeset;
+  /**
+   * Resolve Content-ID references ($N) in a BatchRequestPart's URL and body.
+   *
+   * Per WRITE-03: $N in a URL or body is substituted with the location URL recorded
+   * for content ID N from a prior 201 response in the same changeset.
+   *
+   * Fast path: returns the original part unchanged when contentIdMap is empty or
+   * no $N patterns match (avoids unnecessary object allocation).
+   *
+   * Per immutability rules: never mutates the readonly BatchRequestPart — returns a new object.
+   * Per T-10-07: substitution uses only URLs already in contentIdMap (populated by our own
+   * 201 responses) — no code evaluation, no cross-changeset leak.
+   */
+  private resolveContentIdReferences;
+  /**
+   * Dispatch a parsed sub-request to the appropriate handler using the given EntityManager.
+   * Uses the EntityManager so changesets can use a transaction-scoped manager.
+   *
+   * Per T-05-03: URL parsing is regex-based, entity operations go through TypeORM parameterized queries.
+   */
+  private dispatchWithManager;
+  /** GET /EntitySet(key) */
+  private dispatchGetByKey;
+  /** GET /EntitySet (collection — basic support) */
+  private dispatchGetCollection;
+  /** POST /EntitySet */
+  private dispatchCreate;
+  /** PATCH /EntitySet(key) */
+  private dispatchUpdate;
+  /**
+   * PUT /EntitySet(key) — full entity replacement.
+   *
+   * Per OData v4 spec (D-01): all entity properties replaced.
+   * Unspecified fields reset to column defaults (null for nullable, default value otherwise).
+   * Distinct from PATCH merge semantics used by dispatchUpdate().
+   *
+   * Uses repo.metadata.columns for column introspection — same pattern as handleReplace().
+   */
+  private dispatchReplace;
+  /** DELETE /EntitySet(key) */
+  private dispatchDelete;
+  /**
+   * Build an OData error response part from an exception.
+   * Never exposes stack traces (T-05-05).
+   */
+  private buildErrorResponse;
+  /**
+   * Resolve a TypeORM entity class from an EDM entity type name.
+   * Matches by checking DataSource metadata for each registered entity class.
+   */
+  private resolveEntityClass;
+}
+//#endregion
+//#region src/batch/batch-response-builder.d.ts
+/**
+ * Build a multipart/mixed batch response from individual operation results.
+ *
+ * @param parts - Array of per-operation response descriptors
+ * @returns Object with `contentType` (for Content-Type header) and `body` (response body string)
+ */
+declare function buildBatchResponse(parts: BatchResponsePart[]): {
+  contentType: string;
+  body: string;
+};
+//#endregion
+//#region src/odata-typeorm.module.d.ts
+/**
+ * DI injection token for the array of TypeORM entity classes
+ * registered via ODataTypeOrmModule.forFeature().
+ */
+declare const TYPEORM_ODATA_ENTITIES: unique symbol;
+/**
+ * TypeOrmEdmInitializer — runs at module init to derive EDM from TypeORM entities
+ * and register them in the EdmRegistry.
+ *
+ * Per D-06, D-16, EDM-06: EDM derivation happens after DataSource is ready (onModuleInit).
+ */
+declare class TypeOrmEdmInitializer implements OnModuleInit {
+  private readonly dataSource;
+  private readonly edmRegistry;
+  private readonly options;
+  private readonly entityClasses;
+  constructor(dataSource: DataSource, edmRegistry: EdmRegistry, options: ODataModuleOptions, entityClasses: EntityClass[]);
+  onModuleInit(): void;
+}
+/**
+ * TypeORM adapter module for @nestjs-odata/core.
+ *
+ * Wraps TypeOrmModule.forFeature() and registers the entity classes
+ * under the TYPEORM_ODATA_ENTITIES token. TypeOrmEdmInitializer runs
+ * at onModuleInit to derive and register OData EDM metadata from TypeORM.
+ *
+ * ODataModule.forRoot() must be imported in the application root module —
+ * EdmRegistry is @Global() so it is available here without an explicit import.
+ *
+ * Usage:
+ *   ODataTypeOrmModule.forFeature([Product, Category])
+ */
+declare class ODataTypeOrmModule {
+  /**
+   * Register TypeORM entity classes for OData auto-derivation.
+   *
+   * @param entities - Array of TypeORM entity classes (decorated with @Entity())
+   * @returns DynamicModule that imports TypeOrmModule.forFeature, provides TYPEORM_ODATA_ENTITIES,
+   *          and wires TypeOrmEdmInitializer to populate the EdmRegistry at onModuleInit
+   */
+  static forFeature(entities: EntityClassOrSchema[], options?: {
+    serviceRoot?: string;
+  }): DynamicModule;
+}
+//#endregion
+//#region src/deriver/typeorm-edm-deriver.d.ts
+/**
+ * TypeOrmEdmDeriver — derives OData v4 EdmEntityConfig[] from TypeORM EntityMetadata.
+ *
+ * Respects OData decorators: @EdmType, @ODataExclude, @ODataEntitySet.
+ * Detects ViewEntity and marks them read-only.
+ * Navigation property types are always namespace-qualified (e.g., 'Default.Category').
+ *
+ * CRITICAL: Never produces Edm.DateTime — all datetime-like types produce Edm.DateTimeOffset.
+ *
+ * Usage (runtime):
+ *   const deriver = new TypeOrmEdmDeriver('Default', 'skip')
+ *   // When called by the module, metadatas come from the registered DataSource
+ *
+ * Usage (testing):
+ *   deriver.deriveEntityTypes([Product], dataSource.entityMetadatas)
+ */
+declare class TypeOrmEdmDeriver implements IEdmDeriver {
+  private readonly namespace;
+  private readonly unmappedTypeStrategy;
+  constructor(namespace: string, unmappedTypeStrategy: UnmappedTypeStrategy);
+  /**
+   * Implement IEdmDeriver — called by the core module.
+   * When entity metadatas are not provided, returns empty (requires integration with DataSource).
+   */
+  deriveEntityTypes(entityClasses: EntityClass[]): EdmEntityConfig[];
+  /**
+   * Overload for direct use with TypeORM EntityMetadata (used in tests and adapter integration).
+   */
+  deriveEntityTypes(entityClasses: EntityClass[], entityMetadatas: EntityMetadata[]): EdmEntityConfig[];
+  private deriveEntity;
+  private deriveProperties;
+  private deriveNavigationProperties;
+}
+//#endregion
+//#region src/translator/filter-visitor.d.ts
+/**
+ * TypeOrmFilterVisitor — translates an OData filter AST into TypeORM
+ * SelectQueryBuilder.andWhere() calls with named parameters.
+ *
+ * All literal values are bound via named parameters (:p1, :p2, ...) — zero
+ * string interpolation in WHERE clauses (T-03-04 mitigation).
+ *
+ * LIKE special characters (%, _) are escaped before use in contains/startswith/endswith
+ * to prevent wildcard injection (T-03-05 mitigation).
+ *
+ * Per SEC-04: Tracks filter AST nesting depth and throws ODataValidationError when
+ * depth exceeds maxFilterDepth. Prevents pathological filter expressions.
+ */
+declare class TypeOrmFilterVisitor implements FilterVisitor<void> {
+  private readonly qb;
+  private readonly alias;
+  private readonly entityType;
+  private readonly maxFilterDepth;
+  private readonly dialect;
+  private readonly repo?;
+  /** Shared param counter — passed between sibling visitors for unique names */
+  paramCount: number;
+  /** Current nesting depth — propagated to sub-visitors for or branches */
+  currentDepth: number;
+  /** Accumulated params from resolveExpression (e.g. arithmetic operands) to merge into andWhere */
+  private pendingParams;
+  constructor(qb: SelectQueryBuilder<ObjectLiteral>, alias: string, entityType: EdmEntityType, maxFilterDepth?: number, dialect?: 'sqlite' | 'postgres' | 'ansi', repo?: Repository<ObjectLiteral> | undefined);
+  /** Entry point: dispatch the root FilterNode to the appropriate visit method */
+  visit(node: FilterNode): void;
+  visitBinaryExpr(node: BinaryExprNode): void;
+  visitUnaryExpr(node: UnaryExprNode): void;
+  visitFunctionCall(node: FunctionCallNode): void;
+  visitLambdaExpr(node: LambdaExprNode): void;
+  private buildAnyClause;
+  private buildAllClause;
+  visitPropertyAccess(_node: PropertyAccessNode): void;
+  visitLiteral(_node: LiteralNode): void;
+  private nextParam;
+  /**
+   * Resolve a FilterNode to an SQL expression string (left side of comparison).
+   * Handles PropertyAccessNode (column ref) and scalar FunctionCallNode (LENGTH, LOWER, etc.).
+   */
+  private resolveExpression;
+  /** Resolve date/time function to dialect-correct SQL. Returns null if not a date function. */
+  private resolveDateFunction;
+  /** Bind an arithmetic operand: Literal nodes become named params; others recurse. */
+  private resolveArithOperand;
+  /** Resolve indexof/substring/concat to parameterized SQL. Returns null if not a string fn. */
+  private resolveStringFunction;
+  /** Extract the raw JS value from a LiteralNode */
+  private extractLiteralValue;
+  /** Apply a LIKE function (contains, startswith, endswith) with escaped value */
+  private applyLikeFunction;
+  /**
+   * Escape LIKE special characters to prevent wildcard injection (T-03-05).
+   * % -> \%, _ -> \_
+   */
+  private escapeLike;
+}
+//#endregion
+//#region src/translator/select-visitor.d.ts
+/**
+ * TypeOrmSelectVisitor — translates an OData $select node into a TypeORM
+ * SelectQueryBuilder.select() call.
+ *
+ * Key properties (primary keys) are always included in the projection even if
+ * not in the $select list (T-03-06 mitigation — avoids identity column gaps).
+ */
+declare class TypeOrmSelectVisitor {
+  private readonly qb;
+  private readonly alias;
+  private readonly entityType;
+  constructor(qb: SelectQueryBuilder<ObjectLiteral>, alias: string, entityType: EdmEntityType);
+  /**
+   * Apply the $select projection to the QueryBuilder.
+   *
+   * - If select.all is true or select.items is absent/empty, do nothing (return all columns).
+   * - Otherwise, build a deduplicated column list and call qb.select().
+   */
+  apply(select: SelectNode): void;
+}
+//#endregion
+//#region src/translator/orderby-visitor.d.ts
+/**
+ * TypeOrmOrderByVisitor — translates OData $orderby items into TypeORM
+ * QueryBuilder.orderBy() / addOrderBy() calls.
+ */
+declare class TypeOrmOrderByVisitor {
+  private readonly qb;
+  private readonly alias;
+  constructor(qb: SelectQueryBuilder<ObjectLiteral>, alias: string);
+  /**
+   * Apply $orderby items to the QueryBuilder.
+   * First item uses orderBy(), subsequent items use addOrderBy().
+   */
+  apply(items: OrderByItem[]): void;
+  private resolvePropertyName;
+}
+//#endregion
+//#region src/translator/pagination-visitor.d.ts
+/**
+ * TypeOrmPaginationVisitor — applies OData $top/$skip pagination to a TypeORM
+ * SelectQueryBuilder via take() and skip().
+ */
+declare class TypeOrmPaginationVisitor {
+  private readonly qb;
+  constructor(qb: SelectQueryBuilder<ObjectLiteral>);
+  /**
+   * Apply pagination to the QueryBuilder.
+   *
+   * - top=0 is valid (returns empty result set) — applies take(0)
+   * - undefined values are skipped (no call made)
+   */
+  paginate(top: number | undefined, skip: number | undefined): void;
+}
+//#endregion
+//#region src/translator/typeorm-query-translator.d.ts
+/**
+ * Translation result from translate() — includes the QueryBuilder and the
+ * expandPaginationMap needed for post-JOIN in-memory slicing (D-13).
+ * When $apply is present, applyProperties contains the projected column names.
+ */
+interface TranslateResult {
+  readonly qb: SelectQueryBuilder<ObjectLiteral>;
+  readonly expandPaginationMap: ReadonlyMap<string, {
+    skip?: number;
+    top?: number;
+  }>;
+  readonly applyProperties?: string[];
+}
+/**
+ * TypeOrmQueryTranslator — orchestrates all visitor classes to translate
+ * an ODataQuery into a TypeORM SelectQueryBuilder, then executes it.
+ *
+ * Implements IQueryTranslator<SelectQueryBuilder<ObjectLiteral>> — the adapter seam
+ * between @nestjs-odata/core query types and TypeORM query building.
+ *
+ * Visitor application order (deterministic):
+ *   1. filter  — WHERE clause (must be first, affects result set)
+ *   1.5 search — $search LIKE conditions (additional WHERE)
+ *   2. apply   — $apply aggregation pipeline (skips select/orderby/expand)
+ *   3. select  — column projection (skipped when $apply present)
+ *   4. orderby — sorting (skipped when $apply present)
+ *   5. pagination — take/skip
+ *   6. expand  — JOINs for navigation properties (skipped when $apply present)
+ */
+declare class TypeOrmQueryTranslator implements IQueryTranslator<TranslateResult> {
+  private readonly repo;
+  private readonly edmRegistry;
+  private readonly options;
+  private readonly searchProvider?;
+  constructor(repo: Repository<ObjectLiteral>, edmRegistry: EdmRegistry, options: ODataModuleResolvedOptions, searchProvider?: ISearchProvider | undefined);
+  /**
+   * Translate an ODataQuery AST into a TypeORM SelectQueryBuilder.
+   * Also returns the expandPaginationMap for post-JOIN slicing (D-13).
+   * Does not execute the query — call execute() for DB access.
+   */
+  translate(query: ODataQuery, entityType: EdmEntityType): TranslateResult;
+  /**
+   * Execute the translated SelectQueryBuilder and return structured results.
+   * Applies post-JOIN in-memory expand pagination after getMany() (D-13).
+   * When $apply is present, uses getRawMany() to preserve aggregate aliases.
+   *
+   * @param translateResult - The result from translate() (qb + expandPaginationMap)
+   * @param includeCount - If true, uses getManyAndCount() to include total count
+   */
+  execute(translateResult: TranslateResult | SelectQueryBuilder<ObjectLiteral>, includeCount: boolean): Promise<ODataQueryResult>;
+}
+//#endregion
+//#region src/translator/typeorm-auto-handler.d.ts
+/**
+ * TypeOrmAutoHandler — handles OData GET and $count requests automatically
+ * using the TypeORM repository and the query translator.
+ *
+ * Provides zero-boilerplate OData endpoint handling:
+ *   - handleGet(): translate + execute OData query, detect next page via top+1 trick
+ *   - handleCount(): strip pagination/select/orderby, return total count for filter
+ *
+ * Per D-13: effectiveTop is clamped by maxTop (T-03-11).
+ * Per D-15: handleCount() strips $top/$skip to avoid Pitfall 3.
+ * Per Pitfall 2: fetches top+1 items to detect next page without a separate count query.
+ *
+ * The EdmEntityType is resolved at request time via EdmRegistry so the provider
+ * can be registered during module compile time before EDM derivation runs at onModuleInit.
+ */
+declare class TypeOrmAutoHandler {
+  private readonly translator;
+  private readonly edmRegistry;
+  private readonly options;
+  private readonly repo;
+  private readonly etagProvider?;
+  private readonly dataSource?;
+  constructor(translator: TypeOrmQueryTranslator, edmRegistry: EdmRegistry, options: ODataModuleResolvedOptions, repo: Repository<ObjectLiteral>, etagProvider?: IETagProvider | undefined, dataSource?: DataSource | undefined);
+  /**
+   * Resolve EdmEntityType from the registry at request time.
+   * Throws if the entity set is not registered.
+   */
+  private resolveEntityType;
+  /**
+   * Handle an OData GET collection request.
+   *
+   * Strategy:
+   *  1. Resolve EdmEntityType via EdmRegistry
+   *  2. Determine effectiveTop (query.top ?? maxTop), clamped to maxTop
+   *  3. Build a modified query with top=effectiveTop+1 to detect next page
+   *  4. Translate to SelectQueryBuilder
+   *  5. Execute (with or without count per query.count)
+   *  6. Check if items.length > effectiveTop (has more pages)
+   *  7. If yes: slice to effectiveTop, build nextLink; otherwise: no nextLink
+   *
+   * @param query - Validated ODataQuery from ODataQueryPipe
+   * @param requestUrl - Base URL of the request for nextLink construction
+   */
+  handleGet(query: ODataQuery, requestUrl: string): Promise<ODataQueryResult>;
+  /**
+   * Handle an OData $count route.
+   *
+   * Per Pitfall 3: strips $top/$skip/$orderby/$select from the query so count
+   * returns total matching rows for the filter, not just the current page count.
+   *
+   * @param query - Validated ODataQuery from ODataQueryPipe
+   */
+  handleCount(query: ODataQuery): Promise<number>;
+  /**
+   * Build an OData nextLink URL with updated $skip and $top parameters.
+   *
+   * @param requestUrl - The current request URL (may contain existing query params)
+   * @param newSkip - The new $skip value for the next page
+   * @param top - The page size ($top value)
+   */
+  buildNextLink(requestUrl: string, newSkip: number, top: number): string;
+  /**
+   * Handle OData GET by key — single entity retrieval.
+   *
+   * Per D-05: returns single entity, throws NotFoundException if not found.
+   * Per D-02: key is parsed from parenthetical format.
+   * Per T-04-08: parseODataKey returns typed values used in parameterized where clause.
+   * Per T-09-05: If-None-Match header supported — returns { __notModified, etag } signal when matched.
+   */
+  handleGetByKey(keyStr: string, entitySetName: string, ifNoneMatchHeader?: string): Promise<unknown>;
+  /**
+   * Handle OData POST — create entity.
+   *
+   * Per D-03: returns 201 + Location header + created entity.
+   * Returns { entity, locationUrl } for the interceptor to set the Location header.
+   * Per T-04-07: TypeORM repo.create() only maps declared columns — unknown fields ignored.
+   * Per T-04-11: entity class acts as whitelist, preventing mass assignment.
+   */
+  handleCreate(body: Record<string, unknown>, entitySetName: string): Promise<{
+    entity: unknown;
+    locationUrl: string;
+  }>;
+  /**
+   * Handle OData POST with deep insert — create parent and nested children atomically.
+   *
+   * Per D-02 (deep insert): navigation property keys in the body identify child collections.
+   * All saves occur within the provided EntityManager (transaction scope).
+   *
+   * Per T-10-05: depth is checked before recursion — throws 400 if depth >= maxDeepInsertDepth.
+   * Per T-10-06: TypeORM repo.create() only maps declared columns — mass assignment safe.
+   *
+   * @param body - Request body (scalar fields + optional navigation property arrays)
+   * @param entitySetName - OData entity set name (e.g. 'Orders')
+   * @param manager - Transaction-scoped EntityManager
+   * @param depth - Current recursion depth (default 0)
+   */
+  handleDeepCreate(body: Record<string, unknown>, entitySetName: string, manager: EntityManager, depth?: number): Promise<{
+    entity: unknown;
+    locationUrl: string;
+  }>;
+  /**
+   * Resolve a TypeORM entity class from an EDM entity type name.
+   * Requires DataSource to be provided.
+   */
+  private resolveEntityClassFromDataSource;
+  /**
+   * Handle OData PATCH — partial update (merge-patch semantics).
+   *
+   * Per D-01: send only changed fields, server merges with existing entity.
+   * Per Pitfall 4: checks preload result for undefined (entity not found case).
+   * Per T-04-08: parseODataKey returns typed values for safe parameterized queries.
+   * Per T-09-04: If-Match header enforces optimistic concurrency — 412 on stale ETag.
+   */
+  handleUpdate(keyStr: string, body: Record<string, unknown>, entitySetName: string, ifMatchHeader?: string): Promise<unknown>;
+  /**
+   * Handle OData PUT — full entity replacement.
+   *
+   * Per D-01 (OData v4 spec): PUT replaces ALL entity properties.
+   * Unspecified fields reset to column defaults (null for nullable, default value otherwise).
+   * This is distinct from PATCH merge semantics.
+   *
+   * Implementation:
+   *  1. Parse key from URL
+   *  2. Validate body key matches URL key (reject 400 on mismatch)
+   *  3. Find existing entity — throw 404 if not found
+   *  4. Validate ETag If-Match (412 on mismatch)
+   *  5. Build full replacement using repo.metadata.columns:
+   *     - Skip isPrimary, isCreateDate, isUpdateDate, isVersion columns
+   *     - body value > column default > null (if nullable) > absent
+   *  6. Save and return
+   *
+   * Per T-10-01: body key mismatch rejected before DB write.
+   * Per T-10-02: repo.create() only maps declared entity columns — mass assignment safe.
+   * Per T-10-03: managed columns (PK, timestamps, version) skipped.
+   * Per T-10-04: ETag If-Match enforcement identical to handleUpdate().
+   */
+  handleReplace(keyStr: string, body: Record<string, unknown>, entitySetName: string, ifMatchHeader?: string): Promise<unknown>;
+  /**
+   * Handle OData DELETE — remove entity.
+   *
+   * Per D-04: returns 204 No Content (void return value).
+   * Per T-04-08: parseODataKey returns typed values for safe parameterized queries.
+   * Per T-09-04: If-Match header enforces optimistic concurrency — 412 on stale ETag.
+   */
+  handleDelete(keyStr: string, entitySetName: string, ifMatchHeader?: string): Promise<void>;
+}
+//#endregion
+//#region src/translator/expand-pagination.d.ts
+/**
+ * Apply post-JOIN pagination to expanded collections.
+ *
+ * TypeORM hydrates relations as JavaScript arrays. After getMany(),
+ * this function slices each expanded collection by the per-expand-item
+ * $top/$skip values recorded during ExpandVisitor traversal.
+ *
+ * Per D-13: In-memory slicing is the v1 approach. Acceptable for
+ * single-level expand pagination. Total result set is already bounded
+ * by maxTop and maxExpandDepth before slicing occurs (T-05-10 accept).
+ *
+ * Mutates items in-place — the hydrated array is replaced with the sliced
+ * version. This avoids allocating a new top-level array.
+ */
+declare function applyExpandPagination(items: ObjectLiteral[], paginationMap: ReadonlyMap<string, {
+  readonly skip?: number;
+  readonly top?: number;
+}>): void;
+//#endregion
+//#region src/translator/search-provider.d.ts
+/**
+ * TypeORM implementation of ISearchProvider.
+ *
+ * Builds parameterized LIKE conditions for $search queries.
+ * Uses @ODataSearchable()-decorated properties to determine which fields to search.
+ *
+ * Search terms are parameterized (never interpolated) and LIKE special characters
+ * (%, _) are escaped before use — mitigates T-11-04 SQL injection.
+ *
+ * If no @ODataSearchable fields are found, throws ODataValidationError with a
+ * clear message instructing the developer to add the decorator.
+ */
+declare class TypeOrmSearchProvider implements ISearchProvider {
+  private readonly dataSource;
+  private readonly edmRegistry;
+  constructor(dataSource: DataSource, edmRegistry: EdmRegistry);
+  /**
+   * Build a parameterized WHERE condition from a parsed $search AST node.
+   *
+   * @param searchNode - Parsed $search expression
+   * @param entitySetName - OData entity set name being searched
+   * @param alias - TypeORM QueryBuilder alias for the entity table
+   * @returns Condition string + named params, or null if unable to build
+   */
+  buildSearchCondition(searchNode: SearchNode, entitySetName: string, alias: string): {
+    condition: string;
+    params: Record<string, unknown>;
+  } | null;
+  /**
+   * Resolve the entity class from the EdmRegistry and DataSource metadata.
+   */
+  private resolveEntityClass;
+  /**
+   * Build a single LIKE condition for a search term across all searchable fields.
+   * Fields are OR'd together: (alias.f1 LIKE :p OR alias.f2 LIKE :p)
+   * Negated terms are wrapped: NOT (...)
+   */
+  private buildTermCondition;
+  /**
+   * Build a binary AND/OR condition combining two recursively-built conditions.
+   */
+  private buildBinaryCondition;
+  /**
+   * Escape LIKE special characters to prevent wildcard injection (T-11-04).
+   * % -> \%, _ -> \_
+   */
+  private escapeLike;
+}
+//#endregion
+//#region src/translator/apply-visitor.d.ts
+/**
+ * TypeOrmApplyVisitor — translates an OData $apply pipeline AST into
+ * TypeORM SelectQueryBuilder GROUP BY / aggregate SQL.
+ *
+ * Handles three step types in pipeline order:
+ * - ApplyFilter: delegates to TypeOrmFilterVisitor (adds WHERE clause)
+ * - ApplyGroupBy: adds GROUP BY columns + aggregate SELECT expressions
+ * - ApplyAggregate: adds aggregate SELECT expressions (no GROUP BY)
+ *
+ * Security: aggregate property names validated against AggregateExpression.method
+ * enum (constrained by parser); aliases validated by parser regex before SQL use.
+ * No user input is directly interpolated into SQL — property/alias names come
+ * from the validated AST (T-11-05 mitigation).
+ *
+ * Returns projected column names (for @odata.context URL construction).
+ */
+declare class TypeOrmApplyVisitor {
+  private readonly qb;
+  private readonly alias;
+  private readonly entityType;
+  private readonly maxFilterDepth;
+  private readonly dialect;
+  private readonly repo;
+  constructor(qb: SelectQueryBuilder<ObjectLiteral>, alias: string, entityType: EdmEntityType, maxFilterDepth: number | undefined, dialect: "sqlite" | "postgres" | "ansi" | undefined, repo: Repository<ObjectLiteral>);
+  /**
+   * Process all steps in an $apply pipeline in order.
+   * Returns all projected column names for @odata.context construction.
+   */
+  apply(applyNode: ApplyNode): string[];
+  private applyStep;
+  /**
+   * ApplyFilter step — delegates to TypeOrmFilterVisitor.
+   * Adds WHERE clause to the query. Returns no projected columns.
+   */
+  private applyFilterStep;
+  /**
+   * ApplyGroupBy step — adds GROUP BY columns and optional aggregate expressions.
+   * Clears existing SELECT first (replaces entity.* with explicit projections).
+   */
+  private applyGroupByStep;
+  /**
+   * ApplyAggregate step (no GROUP BY) — adds aggregate SELECT expressions.
+   * Clears existing SELECT first (replaces entity.* with explicit projections).
+   */
+  private applyAggregateStep;
+  /**
+   * Build the SQL aggregate function expression for a single AggregateExpression.
+   *
+   * Method mapping:
+   * - count with $count property => COUNT(*)
+   * - count with field => COUNT(alias.field)
+   * - sum => SUM(alias.field)
+   * - avg => AVG(alias.field)
+   * - min => MIN(alias.field)
+   * - max => MAX(alias.field)
+   * - countdistinct => COUNT(DISTINCT alias.field)
+   */
+  private buildAggregateSql;
+}
+//#endregion
+//#region src/etag/typeorm-etag.provider.d.ts
+/**
+ * TypeORM implementation of IETagProvider.
+ *
+ * Discovers the ETag source column per entity set in priority order:
+ *   1. @ODataETag() decorator (explicit opt-in takes precedence)
+ *   2. TypeORM @UpdateDateColumn (automatic fallback via isUpdateDate)
+ *
+ * ETag format: W/"<base64-encoded column value>"
+ * This is deterministic and changes whenever the column value changes.
+ *
+ * Caches column name resolution per entity set for performance.
+ */
+declare class TypeOrmETagProvider implements IETagProvider {
+  private readonly dataSource;
+  private readonly edmRegistry;
+  private readonly cache;
+  constructor(dataSource: DataSource, edmRegistry: EdmRegistry);
+  /**
+   * Get the ETag column name for an entity set.
+   * Returns undefined if neither @ODataETag nor @UpdateDateColumn is found.
+   * Results are cached to avoid repeated metadata reflection.
+   */
+  getETagColumn(entitySetName: string): string | undefined;
+  /**
+   * Compute a weak ETag string from an entity's ETag column value.
+   * Format: W/"<base64-encoded string value>"
+   */
+  computeETag(entity: Record<string, unknown>, etagColumn: string): string;
+  /**
+   * Validate an If-Match header value against the current entity.
+   * Returns true if the ETag matches (safe to proceed with mutation).
+   */
+  validateIfMatch(ifMatchValue: string, entity: Record<string, unknown>, etagColumn: string): boolean;
+  private resolveETagColumn;
+}
+//#endregion
+//#region src/index.d.ts
+declare const VERSION = "0.0.1";
+//#endregion
+export { BatchController, BatchRequest, BatchResponse, ODataTypeOrmModule, TYPEORM_ODATA_ENTITIES, type TranslateResult, TypeOrmApplyVisitor, TypeOrmAutoHandler, TypeOrmETagProvider, TypeOrmEdmDeriver, TypeOrmEdmInitializer, TypeOrmFilterVisitor, TypeOrmOrderByVisitor, TypeOrmPaginationVisitor, TypeOrmQueryTranslator, TypeOrmSearchProvider, TypeOrmSelectVisitor, VERSION, applyExpandPagination, buildBatchResponse };
+//# sourceMappingURL=index.d.cts.map