@expressots/core 4.0.0-preview.1 → 4.0.0-preview.3

package/lib/cjs/types/application/bootstrap.d.ts

@@ -216,52 +216,147 @@ export interface EnvironmentFileConfig {
     skipFileLoading?: boolean;
 }
 /**
- * Options for loadEnvSync().
- * @public API
+ * Options for {@link loadEnvSync}.
+ *
+ * `loadEnvSync()` is the recommended way to populate `process.env` before
+ * `bootstrap()` runs. Call it at the top of `src/main.ts` (or your config
+ * module) so every subsequent `Env.*` builder, `defineConfig()` call, and
+ * DI binding can read the loaded values.
+ *
+ * ### File-loading order (last wins)
+ *
+ * | Step | File | Purpose |
+ * |------|------|---------|
+ * | 1 | `.env` | Shared defaults (committed) |
+ * | 2 | `.env.local` | Local-only overrides (gitignored) |
+ * | 3 | `.env.{env}.local` | Per-environment local override |
+ * | 4 | `.env.{env}` | Per-environment values (highest priority) |
+ *
+ * `{env}` is resolved from `process.env.NODE_ENV` (defaults to `"development"`).
+ * If a `files` mapping is provided, the mapped filename replaces `.env.{env}`.
+ *
+ * @example
+ * ```typescript
+ * // 1. Zero-config (loads .env + .env.development by convention)
+ * loadEnvSync();
+ *
+ * // 2. Custom file names per environment
+ * loadEnvSync({
+ *   files: {
+ *     development: ".env",
+ *     production: ".env.prod",
+ *     staging: ".env.staging",
+ *   },
+ * });
+ *
+ * // 3. Force reload after hot-module replacement
+ * loadEnvSync({ force: true });
+ * ```
+ *
+ * @see {@link loadEnvSync} for the function itself
+ * @see {@link BootstrapOptions.envFileConfig} for the bootstrap()-level alternative
+ * @public
  */
 export interface LoadEnvSyncOptions {
     /**
-     * Custom mapping of environment names to .env file names.
-     * @default Uses convention: `.env.{currentEnvironment}`
+     * Map environment names to custom `.env` file paths.
+     *
+     * Only the entry matching the **current** `NODE_ENV` is used at runtime.
+     * Unmapped environments fall back to the convention `.env.{NODE_ENV}`.
+     *
+     * @default undefined (convention: `.env.{NODE_ENV}`)
+     *
+     * @example
+     * ```typescript
+     * files: {
+     *   development: ".env",         // NODE_ENV=development  -> loads .env
+     *   production:  ".env.prod",    // NODE_ENV=production   -> loads .env.prod
+     *   test:        ".env.test",    // NODE_ENV=test         -> loads .env.test
+     * }
+     * ```
      */
     files?: EnvironmentFileMap;
     /**
-     * Force reload even if already loaded.
-     * Useful for hot reload scenarios.
+     * Reload environment files even if they were already loaded in this process.
+     *
+     * By default `loadEnvSync()` is a no-op after the first successful call
+     * (tracked via `process.env._EXPRESSOTS_ENV_LOADED`). Set `force: true`
+     * to re-read all files, useful after a hot-module replacement cycle.
+     *
      * @default false
      */
     force?: boolean;
 }
 /**
- * Synchronously load .env files BEFORE defineConfig() resolves.
+ * Synchronously load `.env` files into `process.env`.
  *
- * Call this at the top of your config file to ensure environment variables
- * are available when defineConfig() runs.
+ * Call this **before** `bootstrap()` or `defineConfig()` so that every
+ * environment variable is available when the rest of the application
+ * resolves configuration, binds services, or reads `Env.*` builders.
  *
- * @param options - Environment file configuration
+ * ### How it works
  *
- * @example
+ * 1. Reads `process.env.NODE_ENV` (defaults to `"development"`).
+ * 2. Loads files in priority order (last file wins on conflicts):
+ *    `.env` → `.env.local` → `.env.{env}.local` → `.env.{env}`
+ * 3. If `options.files` maps the current environment to a custom name
+ *    (e.g. `{ production: ".env.prod" }`), that name replaces `.env.{env}`.
+ * 4. Missing files are silently skipped.
+ * 5. Sets `process.env._EXPRESSOTS_ENV_LOADED = "true"` so subsequent
+ *    calls are no-ops (unless `force: true`).
+ *
+ * ### Important
+ *
+ * `NODE_ENV` must already be set in the **shell** (or inherited from
+ * the process) before `loadEnvSync()` runs. The function reads
+ * `process.env.NODE_ENV` to decide which file to load; it does **not**
+ * derive the environment from file contents.
+ *
+ * @param options - See {@link LoadEnvSyncOptions} for all fields.
+ *
+ * @example Zero-config (recommended for most apps)
  * ```typescript
- * // config.ts
- * import { defineConfig, Env, loadEnvSync } from "@expressots/core";
+ * // src/main.ts
+ * import { bootstrap, loadEnvSync } from "@expressots/core";
+ * import { App } from "./app";
+ *
+ * loadEnvSync();          // .env + .env.development (or .env.production, etc.)
+ * void bootstrap(App);
+ * ```
  *
- * // Load .env files first
+ * @example Custom file mapping
+ * ```typescript
  * loadEnvSync({
  *   files: {
- *     development: ".env.dev",
- *     production: ".env.prod",
+ *     development: ".env",
+ *     production:  ".env.prod",
+ *     staging:     ".env.staging",
  *   },
  * });
+ * // With NODE_ENV=production  -> .env + .env.prod
+ * // With NODE_ENV=development -> .env  (mapped to itself, so loaded once)
+ * ```
+ *
+ * @example With defineConfig()
+ * ```typescript
+ * // src/config.ts
+ * import { defineConfig, Env, loadEnvSync } from "@expressots/core";
+ *
+ * loadEnvSync({ files: { production: ".env.prod" } });
  *
- * // Now defineConfig() will read from loaded .env files
  * export const appConfig = defineConfig({
- *   server: {
- *     port: Env.port("PORT", { default: 3000 }),
- *   },
+ *   server: { port: Env.port("PORT", { default: 3000 }) },
  * });
  * ```
  *
- * @public API
+ * @example Force reload (hot-module replacement)
+ * ```typescript
+ * loadEnvSync({ force: true });
+ * ```
+ *
+ * @see {@link LoadEnvSyncOptions} for option details
+ * @see {@link BootstrapOptions.envFileConfig} for the bootstrap()-level alternative
+ * @public
  */
 export declare function loadEnvSync(options?: LoadEnvSyncOptions): void;
 /**
@@ -471,14 +566,91 @@ export interface BootstrapOptions {
     envFileConfig?: EnvironmentFileConfig;
 }
 /**
- * Bootstrap with BootstrapOptions (existing behavior).
+ * Start the application with explicit options.
+ *
+ * Use this overload when you need to control the port, app metadata,
+ * environment selection, or `.env` file loading/validation.
+ *
+ * @param AppClass - Your class that extends `AppExpress`.
+ * @param options  - See {@link BootstrapOptions} for every field.
+ * @returns The running server instance.
+ *
+ * @example Port + environment + validation
+ * ```typescript
+ * await bootstrap(App, {
+ *   port: 4000,
+ *   appName: "My API",
+ *   currentEnvironment: "production",
+ *   envFileConfig: {
+ *     files: { production: ".env.prod" },
+ *     required: ["DATABASE_URL", "JWT_SECRET"],
+ *     validateValues: true,
+ *   },
+ * });
+ * ```
+ *
+ * @example Dynamic port for testing
+ * ```typescript
+ * const server = await bootstrap(App, { port: 0 });
+ * const port = await server.getPort();
+ * ```
+ *
+ * @example Container / CI (no file I/O)
+ * ```typescript
+ * await bootstrap(App, {
+ *   envFileConfig: {
+ *     skipFileLoading: true,
+ *     required: ["DATABASE_URL"],
+ *   },
+ * });
+ * ```
+ *
+ * @public
  */
 export declare function bootstrap(AppClass: new () => IWebServer, options: BootstrapOptions): Promise<IWebServerPublic>;
 /**
- * Bootstrap with config object (new convenience overload).
+ * Start the application with a type-safe config object from `defineConfig()`.
+ *
+ * Pass the resolved config directly; `bootstrap()` extracts `app`, `server`,
+ * and `bootstrap.envFileConfig` automatically.
+ *
+ * @param AppClass - Your class that extends `AppExpress`.
+ * @param config   - Object returned by `defineConfig().values` (or matching
+ *                   the {@link BootstrapConfig} shape).
+ * @returns The running server instance.
+ *
+ * @example
+ * ```typescript
+ * import { appConfig } from "./config";
+ *
+ * await bootstrap(App, appConfig.values);
+ * // appConfig.values has { app, server, bootstrap } from defineConfig()
+ * ```
+ *
+ * @public
  */
 export declare function bootstrap(AppClass: new () => IWebServer, config: BootstrapConfig): Promise<IWebServerPublic>;
 /**
- * Bootstrap with no options (zero-config).
+ * Start the application with zero configuration.
+ *
+ * - Listens on `process.env.PORT` or **3000**.
+ * - Reads `appName` and `appVersion` from `package.json`.
+ * - Does **not** load any `.env` files (opt-in via {@link BootstrapOptions.envFileConfig}
+ *   or by calling {@link loadEnvSync} before this).
+ * - Sets up graceful shutdown on `SIGINT` / `SIGTERM`.
+ *
+ * @param AppClass - Your class that extends `AppExpress`.
+ * @returns The running server instance.
+ *
+ * @example
+ * ```typescript
+ * import { bootstrap, loadEnvSync } from "@expressots/core";
+ * import { App } from "./app";
+ *
+ * loadEnvSync();           // optional: load .env files first
+ * await bootstrap(App);    // starts on PORT from .env or 3000
+ * ```
+ *
+ * @public
  */
 export declare function bootstrap(AppClass: new () => IWebServer): Promise<IWebServerPublic>;

package/lib/cjs/types/config/config.interfaces.d.ts

@@ -409,7 +409,13 @@ export interface DefineConfigOptions {
     throwOnError?: boolean;
     /**
      * Log validation results.
-     * @default "info"
+     *
+     * - `"warn"` (default): only warnings and errors are printed.
+     * - `"info"` / `"debug"`: prints the "CONFIGURATION LOADED" success banner
+     *   plus warnings and errors.
+     * - `"error"`: only errors.
+     * - `"none"`: completely silent.
+     * @default "warn"
      */
     logLevel?: ConfigLogLevel;
     /**

package/lib/cjs/types/config/env-field-builders.d.ts

@@ -274,6 +274,42 @@ declare function array<T extends string | number>(envVar: string, options?: Arra
  *
  * @public API
  */
+/**
+ * Returns true when the current Node environment (`NODE_ENV`) matches the
+ * supplied name. Pass an array to match any of several names. The comparison
+ * is case-insensitive and falls back to `"development"` when `NODE_ENV` is
+ * unset, mirroring the convention used elsewhere in the framework.
+ *
+ * ```ts
+ * const config = defineConfig({
+ *   server: { port: when(Env.is("production"), 443, 3000) },
+ * });
+ * ```
+ *
+ * @public API
+ */
+declare function isEnvironment(name: string | Array<string>): boolean;
+/**
+ * Conditional helper for environment-specific config values.
+ *
+ * `when(condition, value, fallback)` returns `value` when `condition` is
+ * truthy, otherwise `fallback`. The condition can be either a boolean
+ * (typically the result of `Env.is(...)`) or a callable that's evaluated
+ * lazily. The latter form lets you defer side-effectful checks until the
+ * config is actually resolved.
+ *
+ * ```ts
+ * const config = defineConfig({
+ *   logging: {
+ *     level: when(Env.is("production"), "info", "debug"),
+ *     pretty: when(() => process.env.NO_COLOR !== "1", true, false),
+ *   },
+ * });
+ * ```
+ *
+ * @public API
+ */
+declare function envWhen<TValue, TFallback>(condition: boolean | (() => boolean), value: TValue, fallback: TFallback): TValue | TFallback;
 export declare const Env: {
     readonly string: typeof string;
     readonly number: typeof number;
@@ -284,5 +320,8 @@ export declare const Env: {
     readonly secret: typeof secret;
     readonly json: typeof json;
     readonly array: typeof array;
+    readonly is: typeof isEnvironment;
+    readonly when: typeof envWhen;
 };
+export { isEnvironment as envIs, envWhen };
 export { string as envString, number as envNumber, boolean as envBoolean, enumField as envEnum, url as envUrl, port as envPort, secret as envSecret, json as envJson, array as envArray, };

package/lib/cjs/types/config/index.d.ts

@@ -56,6 +56,6 @@
  * ```
  */
 export { defineConfig, Env } from "./define-config.js";
-export { envString, envNumber, envBoolean, envEnum, envUrl, envPort, envSecret, envJson, envArray, } from "./env-field-builders.js";
+export { envString, envNumber, envBoolean, envEnum, envUrl, envPort, envSecret, envJson, envArray, envIs, envWhen, } from "./env-field-builders.js";
 export type { ConfigValueType, ConfigEnvironment, ConfigLogLevel, BaseFieldOptions, StringFieldOptions, NumberFieldOptions, BooleanFieldOptions, EnumFieldOptions, UrlFieldOptions, PortFieldOptions, SecretFieldOptions, JsonFieldOptions, ArrayFieldOptions, ConfigField, ConfigValidationError, ConfigValidationResult, ConfigSchemaValue, ConfigSchema, DefineConfigOptions, ConfigChangeEvent, SecretValue, ResolvedConfig, IConfigInstance, } from "./config.interfaces.js";
 export { createSecretValue, isSecretValue } from "./secret-value.js";

package/lib/cjs/types/framework-version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Framework version string surfaced in startup banners and diagnostics.
+ *
+ * This file is auto-synced from the root `package.json` by
+ * `scripts/sync-version.js` before each build. Do not edit by hand.
+ */
+export declare const FRAMEWORK_VERSION = "4.0.0-preview.3";

package/lib/cjs/types/lazy-loading/index.d.ts

@@ -36,6 +36,7 @@
  */
 export type { PreloadHint, ModuleLoadStatus, LazyModuleConfig, LazyModuleFactory, ILazyModule, ILazyModuleLoader, ModuleLoadStatistics, ILazyModuleManager, ModuleRecommendation, ApplyRecommendationsOptions, ILazyLoadMetrics, WarmupStrategy, WarmupConfig, ILazyModuleWarmup, LoadingPhase, ProgressiveLoadingConfig, LazyLoadingOptions, LazyLoadingSetupResult, } from "./lazy.interfaces.js";
 export { LazyModule, CreateLazyModule, createLazyModule, isLazyModule, getModuleName, LAZY_MODULE_METADATA_KEY, } from "./lazy-module.js";
+export { withPreloadHint, withLazyConfig } from "./lazy-module-helpers.js";
 export { LazyModuleLoader, createLazyModuleLoader, } from "./lazy-module-loader.js";
 export { LazyModuleManager, createLazyModuleManager, } from "./lazy-module-manager.js";
 export { LazyLoadMetrics, createLazyLoadMetrics } from "./lazy-load-metrics.js";

package/lib/cjs/types/lazy-loading/lazy-module-helpers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Standalone (free-function) wrappers around `LazyModule` chain methods.
+ *
+ * The fluent API (`module.withPreloadHint(...).withLazyConfig(...)`) remains
+ * the recommended style. These helpers exist so users can compose lazy
+ * configurations with point-free style or apply the same hint to a list of
+ * modules:
+ *
+ * ```ts
+ * import { CreateLazyModule, withPreloadHint, withLazyConfig } from "@expressots/core";
+ *
+ * const Admin = withPreloadHint(
+ *   CreateLazyModule([AdminController]),
+ *   "low",
+ * );
+ *
+ * const Analytics = withLazyConfig(
+ *   CreateLazyModule([AnalyticsController]),
+ *   { preloadHint: "medium", prefetchAfterIdle: 5000 },
+ * );
+ * ```
+ *
+ * @public API
+ */
+import type { ILazyModule, LazyModuleConfig, PreloadHint } from "./lazy.interfaces.js";
+/**
+ * Set a preload hint on the supplied lazy module and return it.
+ *
+ * Equivalent to `module.withPreloadHint(hint)`. Returned reference is the same
+ * instance — no copy is made.
+ *
+ * @public API
+ */
+export declare function withPreloadHint(module: ILazyModule, hint: PreloadHint): ILazyModule;
+/**
+ * Merge the supplied partial config into the lazy module and return it.
+ *
+ * Equivalent to `module.withLazyConfig(config)`.
+ *
+ * @public API
+ */
+export declare function withLazyConfig(module: ILazyModule, config: Partial<LazyModuleConfig>): ILazyModule;

package/lib/cjs/types/middleware/index.d.ts

@@ -2,7 +2,6 @@ export { Middleware, ExpressHandler, ExpressoMiddleware, MiddlewareOptions, Midd
 export { ErrorHandlerOptions, IMiddleware, HealthCheckOptions, } from "./middleware-interface.js";
 export { middlewareResolver, isMiddlewareAvailable, isPackageAvailable, resolvePackage, getAvailableMiddleware, getRegisteredMiddleware, clearMiddlewareCache, getPackageName, MIDDLEWARE_REGISTRY, RegisteredMiddlewareName, } from "./middleware-resolver.js";
 export { MiddlewareProfiler, MiddlewareMetrics, ProfilerStats, } from "./middleware-profiler.js";
-export { MiddlewarePresetName, MiddlewarePreset, PresetMiddlewareConfig, ApplyPresetOptions, MIDDLEWARE_PRESETS, getPreset, getPresetNames, getPresetsByTag, createPreset, mergePresets, } from "./middleware-presets.js";
 export type { OptionsJson } from "./interfaces/body-parser.interface.js";
 export type { CorsOptions } from "./interfaces/cors.interface.js";
 export type { CompressionOptions } from "./interfaces/compression.interface.js";
@@ -19,6 +18,7 @@ export type * as IMorgan from "./interfaces/morgan.interface.js";
 export { ContentNegotiationService, FormatterRegistry, AcceptHeaderParser, JsonFormatter, XmlFormatter, CsvFormatter, YamlFormatter, PlainTextFormatter, } from "./content-negotiation/index.js";
 export type { IContentFormatter, ContentNegotiationOptions, AcceptHeaderEntry, NegotiationResult, CsvFormatOptions, XmlFormatOptions, YamlFormatOptions, } from "./interfaces/content-negotiation.interface.js";
 export { use, compose, when, parallel, timeout } from "./middleware-utils.js";
+export { definePreset, applyPreset, getStandalonePresetNames, clearStandalonePresets, } from "./presets-standalone.js";
 export { MiddlewareRegistry, getMiddlewareRegistry, resetMiddlewareRegistry, } from "./middleware-registry.js";
 export type { MiddlewareEntry as RegistryMiddlewareEntry } from "./middleware-registry.js";
 export { setGlobalUploadConfig, getGlobalUploadConfig, hasGlobalUploadConfig, clearGlobalUploadConfig, mergeUploadConfigs, } from "./upload-registry.js";

package/lib/cjs/types/middleware/middleware-service.d.ts

@@ -250,6 +250,7 @@ export declare class Middleware implements IMiddleware {
     private profiler;
     private profilingEnabled;
     private customPresets;
+    private _lastPreset;
     private registry;
     private startupLogs;
     private registeredMiddlewareNames;
@@ -699,8 +700,28 @@ export declare class Middleware implements IMiddleware {
      * Get all available presets.
      */
     getAllPresets(): Record<string, V4MiddlewareConfig>;
+    /**
+     * Returns info about the last applied preset (name, whether overrides
+     * were used, and the effective merged config). Used by the adapter to
+     * forward preset metadata to Studio.
+     */
+    getLastAppliedPreset(): {
+        name: string;
+        hasOverrides: boolean;
+        config: V4MiddlewareConfig;
+    } | null;
     /**
      * Get built-in presets.
+     *
+     * Each preset is tuned for a specific workload:
+     * - api: REST APIs (large payloads, rate-limited, strict CORS)
+     * - web: traditional server-rendered apps (cookies, sessions, relaxed CORS)
+     * - spa: single-page apps served with static fallback
+     * - microservice: internal service-to-service (minimal surface, no security)
+     * - graphql: single endpoint with large JSON payloads
+     * - minimal: parsing only, no security or compression
+     * - development: relaxed for local iteration, verbose logging
+     * - production: hardened defaults for shipped deployments
      */
     private getBuiltInPresets;
     /**

package/lib/cjs/types/middleware/presets-standalone.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Standalone (free-function) wrappers around the v4 middleware preset system.
+ *
+ * These exist alongside the `Middleware.definePreset` / `Middleware.applyPreset`
+ * instance methods so user code that doesn't have DI access to the `Middleware`
+ * provider — for example, declarative config files outside of the request
+ * lifecycle — can still register and apply presets.
+ *
+ * Usage:
+ * ```ts
+ * import { definePreset, applyPreset } from "@expressots/core";
+ *
+ * definePreset("my-api", {
+ *   parse: { json: { limit: "1mb" } },
+ *   security: { cors: { origin: "https://app.example.com" } },
+ * });
+ *
+ * // ...later, inside configureServices(), with the Middleware DI provider:
+ * applyPreset(this.services.middleware, "my-api");
+ * ```
+ *
+ * @public API
+ */
+import type { Middleware } from "./middleware-service.js";
+import type { MiddlewareConfig } from "./middleware-config.js";
+/**
+ * Register a custom middleware preset under the given name.
+ *
+ * The preset is stored in a module-level registry so it can be referenced
+ * later by `applyPreset(middleware, name)`. Calling `definePreset` with an
+ * existing name overwrites the previous definition.
+ *
+ * @param name   unique identifier for the preset
+ * @param config v4 middleware config object describing the preset
+ *
+ * @public API
+ */
+export declare function definePreset(name: string, config: MiddlewareConfig): void;
+/**
+ * Apply a previously defined preset (built-in or registered via
+ * `definePreset`) to the supplied `Middleware` instance.
+ *
+ * Resolution order:
+ *  1. Built-in v4 presets (`api`, `web`, `spa`, `microservice`, `graphql`,
+ *     `minimal`, `development`, `production`) are matched by the
+ *     `Middleware` instance itself.
+ *  2. Custom presets previously registered via `Middleware.definePreset`
+ *     on the same instance.
+ *  3. Custom presets registered via the standalone `definePreset` here —
+ *     these are forwarded to the instance on demand.
+ *
+ * @param middleware the active `Middleware` provider (typically resolved from
+ *                   the DI container inside `configureServices()`)
+ * @param name       preset to apply
+ * @param overrides  optional partial config that is merged on top of the
+ *                   preset before application
+ *
+ * @public API
+ */
+export declare function applyPreset(middleware: Middleware, name: string, overrides?: Partial<MiddlewareConfig>): void;
+/**
+ * Returns the names of every preset registered through the standalone
+ * `definePreset` helper. Built-in presets and per-instance custom presets
+ * are NOT included — those live on the `Middleware` instance.
+ *
+ * @public API
+ */
+export declare function getStandalonePresetNames(): Array<string>;
+/**
+ * Remove every preset registered through the standalone `definePreset`
+ * helper. Useful in tests; rarely needed at runtime.
+ *
+ * @public API
+ */
+export declare function clearStandalonePresets(): void;

package/lib/cjs/types/provider/db-in-memory/adapter/in-memory.adapter.d.ts

@@ -125,6 +125,8 @@ export interface InMemoryDatabaseOptions {
     timestamps?: boolean;
     /** Enable soft deletes by default for all tables */
     softDelete?: boolean;
+    /** Maximum number of records per table (0 = unlimited) */
+    maxRecordsPerTable?: number;
     /** Persistence configuration */
     persist?: {
         /** Storage type */

package/lib/cjs/types/provider/db-in-memory/index.d.ts

@@ -4,6 +4,14 @@
  * A high-performance, Prisma-compatible in-memory database
  * for ExpressoTS applications.
  *
+ * Scope: this database is intended for development, testing, and
+ * prototyping. Data lives in process memory (with optional file
+ * snapshots) and does not provide the crash safety, concurrency, or
+ * multi-process guarantees of a real database engine. It implements the
+ * universal `IDataAdapter` contract so it can be swapped for a
+ * production adapter (Prisma, TypeORM, etc.) without rewriting
+ * repositories.
+ *
  * Features:
  * - Prisma-like query API
  * - Type-safe queries with TypeScript
@@ -56,7 +64,7 @@ export { InMemoryDBProvider, InMemoryDBConfig, BaseRepository, } from "./db.prov
 export { IDataAdapter, ITableAdapter, IMultiTableAdapter, IReactiveDataAdapter, ISubscription, ChangeEvent, ChangeType, InMemoryAdapter, InMemoryAdapterOptions, InMemoryDatabase, InMemoryDatabaseOptions, } from "./adapter/index.js";
 export { IEntity, ITimestampedEntity, ISoftDeleteEntity, Entity, EntityOptions, EntityMetadata, PrimaryKey, AutoGenerate, AutoGenerateStrategy, Index, IndexOptions, Unique, Nullable, Default, HasMany, HasOne, BelongsTo, ManyToMany, RelationType, RelationMetadata, SchemaRegistry, DB_METADATA_KEYS, } from "./schema/index.js";
 export { StringFilter, NumberFilter, BooleanFilter, DateFilter, FieldFilter, WhereInput, WhereUniqueInput, OrderByInput, SortOrder, SelectInput, IncludeInput, FindUniqueArgs, FindFirstArgs, FindManyArgs, CreateArgs, CreateInput, CreateManyArgs, UpdateArgs, UpdateInput, UpdateManyArgs, UpsertArgs, DeleteArgs, DeleteManyArgs, CountArgs, CountSelect, AggregateArgs, AggregateResult, NumericFieldsOnly, GroupByArgs, BatchPayload, TransactionClient, QueryEngine, } from "./query/index.js";
-export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, } from "./storage/index.js";
+export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, MaxRecordsExceededError, EntityValidationError, } from "./storage/index.js";
 export { IRepository, IDataTable, IDataProvider, } from "./db-in-memory.interface.js";
 export { InMemoryDataProvider, InMemoryDataTable, } from "./db-in-memory.provider.js";
 export { EntityNotFoundError as LegacyEntityNotFoundError, EntityAlreadyExistsError as LegacyEntityAlreadyExistsError, } from "./db-in-memory.types.js";

package/lib/cjs/types/provider/db-in-memory/query/query-engine.d.ts

@@ -7,7 +7,7 @@
  */
 import { IEntity } from "../schema/entity.interface.js";
 import { MemoryStore } from "../storage/memory-store.js";
-import { WhereInput, OrderByInput, FindManyArgs, SelectInput, AggregateArgs, AggregateResult } from "./query.types.js";
+import { WhereInput, WhereUniqueInput, OrderByInput, FindManyArgs, SelectInput, AggregateArgs, AggregateResult } from "./query.types.js";
 /**
  * Query Engine for parsing and executing Prisma-like queries.
  *
@@ -72,6 +72,19 @@ export declare class QueryEngine<T extends IEntity> {
      * @returns Paginated entities
      */
     executePagination(entities: Array<T>, skip?: number, take?: number): Array<T>;
+    /**
+     * Apply cursor-based pagination. The cursor identifies a record (by id or
+     * any other field combination) within the ordered result set; the returned
+     * slice starts at that record. Combine with `skip` (typically `skip: 1` to
+     * exclude the cursor itself) and `take`.
+     *
+     * Should be applied after `orderBy` and before `skip`/`take`.
+     *
+     * @param entities - Ordered entities to slice
+     * @param cursor - Unique cursor identifying the start record
+     * @returns Entities starting at the cursor (empty array if not found)
+     */
+    executeCursor(entities: Array<T>, cursor?: WhereUniqueInput<T>): Array<T>;
     /**
      * Get distinct entities by specified fields.
      * @param entities - Entities to filter

package/lib/cjs/types/provider/db-in-memory/schema/decorators.d.ts

@@ -306,6 +306,20 @@ export declare class SchemaRegistry {
      * @public API
      */
     static getRelations(target: new (...args: Array<unknown>) => unknown): Array<RelationMetadata>;
+    /**
+     * Get primary key field names for an entity.
+     * @param target - Entity class
+     * @returns Array of primary key field names
+     * @public API
+     */
+    static getPrimaryKeys(target: new (...args: Array<unknown>) => unknown): Array<string | symbol>;
+    /**
+     * Get nullable field names for an entity.
+     * @param target - Entity class
+     * @returns Array of nullable field names
+     * @public API
+     */
+    static getNullableFields(target: new (...args: Array<unknown>) => unknown): Array<string | symbol>;
     /**
      * Clear all registered entities (useful for testing).
      * @public API

package/lib/cjs/types/provider/db-in-memory/storage/index.d.ts

@@ -2,4 +2,4 @@
  * Storage Module Exports
  * @module db-in-memory/storage
  */
-export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, } from "./memory-store.js";
+export { MemoryStore, MemoryStoreOptions, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, MaxRecordsExceededError, EntityValidationError, } from "./memory-store.js";