@expressots/core 3.0.0 → 4.0.0-preview.1

package/lib/cjs/provider/db-in-memory/db-in-memory.provider.js

@@ -1,19 +1,18 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryDataTable = exports.InMemoryDataProvider = void 0;
-const inversify_1 = require("../../di/inversify");
-const db_in_memory_types_1 = require("./db-in-memory.types");
+const db_in_memory_types_js_1 = require("./db-in-memory.types.js");
 /**
- * In-memory data provider implementation.
+ * @deprecated Use {@link InMemoryDBProvider} (v4) instead.
+ *
+ * Kept for backward compatibility but no longer auto-registered via DI.
+ * Users who depend on the v3 API should bind it manually:
+ * ```ts
+ * container.bind(InMemoryDataProvider).toSelf().inSingletonScope();
+ * ```
  * @public API
  */
-let InMemoryDataProvider = class InMemoryDataProvider {
+class InMemoryDataProvider {
     constructor() {
         this.name = "In Memory DB Provider";
         this.version = "3.0.0";
@@ -28,11 +27,8 @@ let InMemoryDataProvider = class InMemoryDataProvider {
         }
         return this.tables.get(tableName);
     }
-};
+}
 exports.InMemoryDataProvider = InMemoryDataProvider;
-exports.InMemoryDataProvider = InMemoryDataProvider = __decorate([
-    (0, inversify_1.injectable)()
-], InMemoryDataProvider);
 /**
  * In-memory data table implementation.
  */
@@ -44,7 +40,7 @@ class InMemoryDataTable {
     }
     async insert(item) {
         if (this.items.has(item.id)) {
-            throw new db_in_memory_types_1.EntityAlreadyExistsError(this.tableName, item.id);
+            throw new db_in_memory_types_js_1.EntityAlreadyExistsError(this.tableName, item.id);
         }
         this.items.set(item.id, item);
         return item;
@@ -59,21 +55,21 @@ class InMemoryDataTable {
     }
     async update(item) {
         if (!this.items.has(item.id)) {
-            throw new db_in_memory_types_1.EntityNotFoundError(this.tableName, item.id);
+            throw new db_in_memory_types_js_1.EntityNotFoundError(this.tableName, item.id);
         }
         this.items.set(item.id, item);
         return item;
     }
     async delete(id) {
         if (!this.items.has(id)) {
-            throw new db_in_memory_types_1.EntityNotFoundError(this.tableName, id);
+            throw new db_in_memory_types_js_1.EntityNotFoundError(this.tableName, id);
         }
         return this.items.delete(id);
     }
     async find(id) {
         const item = this.items.get(id);
         if (!item) {
-            throw new db_in_memory_types_1.EntityNotFoundError(this.tableName, id);
+            throw new db_in_memory_types_js_1.EntityNotFoundError(this.tableName, id);
         }
         return item;
     }

package/lib/cjs/provider/db-in-memory/db.provider.js

@@ -0,0 +1,402 @@
+"use strict";
+/**
+ * In-Memory Database Provider for ExpressoTS
+ *
+ * The main provider that integrates the in-memory database
+ * with the ExpressoTS framework, including health checks,
+ * metrics, and lifecycle management.
+ *
+ * @module db-in-memory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = exports.InMemoryDBProvider = void 0;
+const index_js_1 = require("./adapter/index.js");
+/**
+ * In-Memory Database Provider for ExpressoTS.
+ *
+ * A high-performance, Prisma-compatible in-memory database
+ * that integrates seamlessly with the ExpressoTS framework.
+ *
+ * Features:
+ * - Prisma-like query API
+ * - Secondary indexes for O(1) lookups
+ * - Automatic ID generation
+ * - Timestamps (createdAt, updatedAt)
+ * - Soft deletes
+ * - Transactions with rollback
+ * - Relation support (HasMany, HasOne, BelongsTo)
+ * - Reactive subscriptions
+ * - Persistence (file-based)
+ * - Health checks
+ * - Metrics collection
+ *
+ * @example
+ * ```typescript
+ * // Inject the provider
+ * constructor(@inject(InMemoryDBProvider) private db: InMemoryDBProvider) {}
+ *
+ * // Access tables
+ * const users = this.db.table<User>("users");
+ *
+ * // Prisma-like queries
+ * const user = await users.create({
+ *   data: { name: "John", email: "john@example.com" }
+ * });
+ *
+ * const adults = await users.findMany({
+ *   where: { age: { gte: 18 } },
+ *   orderBy: { name: "asc" },
+ *   take: 10
+ * });
+ * ```
+ *
+ * @public API
+ */
+/**
+ * Not auto-registered. Bind explicitly when you need an in-memory store:
+ * ```ts
+ * import { InMemoryDBProvider } from "@expressots/core";
+ * container.bind(InMemoryDBProvider).toSelf().inSingletonScope();
+ * ```
+ */
+class InMemoryDBProvider {
+    constructor(config = {}) {
+        // ═══════════════════════════════════════════════════════════════════════════
+        // PROVIDER METADATA
+        // ═══════════════════════════════════════════════════════════════════════════
+        this.name = "In-Memory Database Provider";
+        this.version = "4.0.0";
+        this.description = "High-performance, Prisma-compatible in-memory database for ExpressoTS";
+        this.author = "ExpressoTS Team";
+        this.repo = "https://github.com/expressots/expressots";
+        this.queryCount = 0;
+        this.totalQueryTime = 0;
+        this.config = {
+            timestamps: true,
+            softDelete: false,
+            logging: false,
+            maxRecordsPerTable: 0,
+            ...config,
+        };
+        this.database = new index_js_1.InMemoryDatabase(this.config);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CONFIGURATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Configure the in-memory database provider.
+     *
+     * Call this method in `configureServices()` to globally configure the database
+     * before the application starts. Configuration changes that affect the database
+     * structure (timestamps, softDelete, persist) will reinitialize the database.
+     *
+     * @param config - Partial configuration to merge with defaults
+     *
+     * @example
+     * ```typescript
+     * // In app.ts configureServices()
+     * async configureServices(): Promise<void> {
+     *   const db = this.Provider.get(InMemoryDBProvider);
+     *   db.configure({
+     *     timestamps: true,
+     *     softDelete: true,
+     *     logging: true,
+     *     persist: {
+     *       storage: "file",
+     *       path: "./data/db.json",
+     *       interval: 30000, // auto-save every 30 seconds
+     *     },
+     *   });
+     * }
+     * ```
+     * @public API
+     */
+    configure(config) {
+        const previousConfig = { ...this.config };
+        // Merge new config with existing
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+        // Check if we need to reinitialize the database
+        // (structural changes require a new database instance)
+        const structuralChange = (config.timestamps !== undefined &&
+            config.timestamps !== previousConfig.timestamps) ||
+            (config.softDelete !== undefined &&
+                config.softDelete !== previousConfig.softDelete) ||
+            config.persist !== undefined;
+        if (structuralChange) {
+            // Preserve existing data if possible
+            const snapshot = this.database.snapshot();
+            // Create new database with updated config
+            this.database = new index_js_1.InMemoryDatabase(this.config);
+            // Restore data if there was any
+            if (snapshot && snapshot !== "{}") {
+                try {
+                    this.database.restore(snapshot);
+                }
+                catch {
+                    // If restore fails, start fresh (schema might have changed)
+                    if (this.config.logging) {
+                        console.log("[InMemoryDB] Could not restore data after config change, starting fresh");
+                    }
+                }
+            }
+            if (this.config.logging) {
+                console.log("[InMemoryDB] Database reinitialized with new configuration");
+            }
+        }
+        if (this.config.logging) {
+            console.log("[InMemoryDB] Configuration updated:", this.config);
+        }
+    }
+    /**
+     * Get the current configuration.
+     * @returns Current database configuration
+     * @public API
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // LIFECYCLE
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Bootstrap the database provider.
+     * Called after the application is fully ready.
+     */
+    async bootstrap() {
+        this.startTime = new Date();
+        // Load persisted data if configured
+        if (this.config.persist) {
+            await this.database.load();
+        }
+        if (this.config.logging) {
+            console.log(`[InMemoryDB] Provider initialized at ${this.startTime.toISOString()}`);
+        }
+    }
+    /**
+     * Shutdown the database provider.
+     * Called when the application shuts down.
+     */
+    async shutdown(signal) {
+        if (this.config.logging) {
+            console.log(`[InMemoryDB] Shutting down (signal: ${signal})`);
+        }
+        this.database.shutdown();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HEALTH CHECK
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Perform a health check on the database.
+     * @returns Health check result
+     */
+    healthCheck() {
+        const stats = this.database.getStats();
+        return {
+            status: "healthy",
+            message: `${stats.tableCount} tables, ${stats.totalRecords} total records`,
+            details: {
+                tables: stats.tableCount,
+                records: stats.totalRecords,
+                uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
+            },
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // METRICS
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Get database metrics.
+     * @returns Metrics object
+     */
+    getMetrics() {
+        const stats = this.database.getStats();
+        const metrics = {
+            "db.tables": stats.tableCount,
+            "db.records.total": stats.totalRecords,
+            "db.queries.total": this.queryCount,
+            "db.queries.avgMs": this.queryCount > 0 ? this.totalQueryTime / this.queryCount : 0,
+        };
+        // Add per-table metrics
+        for (const table of stats.tables) {
+            metrics[`db.table.${table.tableName}.records`] = table.recordCount;
+            metrics[`db.table.${table.tableName}.memory`] = table.memoryEstimate;
+        }
+        return metrics;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // DATABASE API
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Get or create a table adapter.
+     *
+     * @param tableName - Name of the table
+     * @param entityClass - Optional entity class for schema metadata
+     * @returns Table adapter with Prisma-like API
+     *
+     * @example
+     * ```typescript
+     * interface User extends IEntity {
+     *   name: string;
+     *   email: string;
+     *   age: number;
+     * }
+     *
+     * const users = db.table<User>("users");
+     *
+     * // Create
+     * const user = await users.create({
+     *   data: { name: "John", email: "john@example.com", age: 30 }
+     * });
+     *
+     * // Find with complex filters
+     * const results = await users.findMany({
+     *   where: {
+     *     OR: [
+     *       { name: { contains: "John" } },
+     *       { age: { gte: 25 } }
+     *     ]
+     *   },
+     *   orderBy: { createdAt: "desc" },
+     *   take: 10
+     * });
+     * ```
+     */
+    table(tableName, entityClass) {
+        return this.database.table(tableName, entityClass);
+    }
+    /**
+     * Execute operations in a transaction.
+     *
+     * @param fn - Transaction function
+     * @returns Result of the transaction function
+     *
+     * @example
+     * ```typescript
+     * await db.transaction(async (tx) => {
+     *   const user = await tx.table<User>("users").create({
+     *     data: { name: "John", email: "john@example.com" }
+     *   });
+     *
+     *   await tx.table<Post>("posts").create({
+     *     data: { title: "Hello", authorId: user.id }
+     *   });
+     * });
+     * ```
+     */
+    async transaction(fn) {
+        return this.database.transaction(fn);
+    }
+    /**
+     * Create a snapshot of all data.
+     * @returns JSON string of all data
+     */
+    snapshot() {
+        return this.database.snapshot();
+    }
+    /**
+     * Restore data from a snapshot.
+     * @param json - JSON string of snapshot data
+     */
+    restore(json) {
+        this.database.restore(json);
+    }
+    /**
+     * Clear all tables.
+     */
+    clear() {
+        this.database.clear();
+    }
+    /**
+     * Get database statistics.
+     * @returns Statistics for all tables
+     */
+    getStats() {
+        return this.database.getStats();
+    }
+    /**
+     * Get the underlying database instance.
+     * @returns InMemoryDatabase instance
+     */
+    getDatabase() {
+        return this.database;
+    }
+}
+exports.InMemoryDBProvider = InMemoryDBProvider;
+// ═══════════════════════════════════════════════════════════════════════════
+// REPOSITORY BASE CLASS
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Base Repository class for the new adapter pattern.
+ *
+ * Provides a convenient base class for creating repositories
+ * that work with the in-memory database.
+ *
+ * @example
+ * ```typescript
+ * @provide(UserRepository)
+ * export class UserRepository extends BaseRepository<User> {
+ *   constructor(@inject(InMemoryDBProvider) db: InMemoryDBProvider) {
+ *     super(db, "users");
+ *   }
+ *
+ *   // Add custom methods
+ *   async findByEmail(email: string): Promise<User | null> {
+ *     return this.adapter.findFirst({
+ *       where: { email }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @public API
+ */
+class BaseRepository {
+    constructor(db, tableName, entityClass) {
+        this.tableName = tableName;
+        this.adapter = db.table(tableName, entityClass);
+    }
+    // Delegate all methods to the adapter
+    async findUnique(args) {
+        return this.adapter.findUnique(args);
+    }
+    async findFirst(args) {
+        return this.adapter.findFirst(args);
+    }
+    async findMany(args) {
+        return this.adapter.findMany(args);
+    }
+    async create(args) {
+        return this.adapter.create(args);
+    }
+    async createMany(args) {
+        return this.adapter.createMany(args);
+    }
+    async update(args) {
+        return this.adapter.update(args);
+    }
+    async updateMany(args) {
+        return this.adapter.updateMany(args);
+    }
+    async upsert(args) {
+        return this.adapter.upsert(args);
+    }
+    async delete(args) {
+        return this.adapter.delete(args);
+    }
+    async deleteMany(args) {
+        return this.adapter.deleteMany(args);
+    }
+    async count(args) {
+        return this.adapter.count(args);
+    }
+    async aggregate(args) {
+        return this.adapter.aggregate(args);
+    }
+    async transaction(fn) {
+        return this.adapter.transaction(fn);
+    }
+}
+exports.BaseRepository = BaseRepository;

package/lib/cjs/provider/db-in-memory/index.js

@@ -1,11 +1,117 @@
 "use strict";
+/**
+ * ExpressoTS In-Memory Database
+ *
+ * A high-performance, Prisma-compatible in-memory database
+ * for ExpressoTS applications.
+ *
+ * Features:
+ * - Prisma-like query API
+ * - Type-safe queries with TypeScript
+ * - Secondary indexes for O(1) lookups
+ * - Automatic ID generation
+ * - Timestamps (createdAt, updatedAt)
+ * - Soft deletes
+ * - Transactions with rollback
+ * - Relation support (HasMany, HasOne, BelongsTo)
+ * - Reactive subscriptions
+ * - Persistence (file-based snapshots)
+ * - Health checks and metrics
+ * - Easy migration to real databases
+ *
+ * @example
+ * ```typescript
+ * // Define entities
+ * interface User extends IEntity {
+ *   name: string;
+ *   email: string;
+ *   age: number;
+ * }
+ *
+ * // Inject the provider
+ * constructor(@inject(InMemoryDBProvider) private db: InMemoryDBProvider) {}
+ *
+ * // Access tables
+ * const users = this.db.table<User>("users");
+ *
+ * // Prisma-like queries
+ * const user = await users.create({
+ *   data: { name: "John", email: "john@example.com", age: 30 }
+ * });
+ *
+ * const adults = await users.findMany({
+ *   where: {
+ *     OR: [
+ *       { name: { contains: "John" } },
+ *       { age: { gte: 18 } }
+ *     ]
+ *   },
+ *   orderBy: { createdAt: "desc" },
+ *   take: 10
+ * });
+ * ```
+ *
+ * @module db-in-memory
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseRepository = exports.EntityAlreadyExistsError = exports.EntityNotFoundError = exports.InMemoryDataTable = exports.InMemoryDataProvider = void 0;
-var db_in_memory_provider_1 = require("./db-in-memory.provider");
-Object.defineProperty(exports, "InMemoryDataProvider", { enumerable: true, get: function () { return db_in_memory_provider_1.InMemoryDataProvider; } });
-Object.defineProperty(exports, "InMemoryDataTable", { enumerable: true, get: function () { return db_in_memory_provider_1.InMemoryDataTable; } });
-var db_in_memory_types_1 = require("./db-in-memory.types");
-Object.defineProperty(exports, "EntityNotFoundError", { enumerable: true, get: function () { return db_in_memory_types_1.EntityNotFoundError; } });
-Object.defineProperty(exports, "EntityAlreadyExistsError", { enumerable: true, get: function () { return db_in_memory_types_1.EntityAlreadyExistsError; } });
-var base_repo_repository_1 = require("./base-repo.repository");
-Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repo_repository_1.BaseRepository; } });
+exports.LegacyBaseRepository = exports.LegacyEntityAlreadyExistsError = exports.LegacyEntityNotFoundError = exports.InMemoryDataTable = exports.InMemoryDataProvider = exports.EntityAlreadyExistsError = exports.EntityNotFoundError = exports.UniqueConstraintError = exports.IdGenerator = exports.IndexManager = exports.MemoryStore = exports.QueryEngine = exports.DB_METADATA_KEYS = exports.SchemaRegistry = exports.ManyToMany = exports.BelongsTo = exports.HasOne = exports.HasMany = exports.Default = exports.Nullable = exports.Unique = exports.Index = exports.AutoGenerate = exports.PrimaryKey = exports.Entity = exports.InMemoryDatabase = exports.InMemoryAdapter = exports.BaseRepository = exports.InMemoryDBProvider = void 0;
+// ═══════════════════════════════════════════════════════════════════════════
+// MAIN PROVIDER
+// ═══════════════════════════════════════════════════════════════════════════
+var db_provider_js_1 = require("./db.provider.js");
+Object.defineProperty(exports, "InMemoryDBProvider", { enumerable: true, get: function () { return db_provider_js_1.InMemoryDBProvider; } });
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return db_provider_js_1.BaseRepository; } });
+// ═══════════════════════════════════════════════════════════════════════════
+// ADAPTER
+// ═══════════════════════════════════════════════════════════════════════════
+var index_js_1 = require("./adapter/index.js");
+// Implementations
+Object.defineProperty(exports, "InMemoryAdapter", { enumerable: true, get: function () { return index_js_1.InMemoryAdapter; } });
+Object.defineProperty(exports, "InMemoryDatabase", { enumerable: true, get: function () { return index_js_1.InMemoryDatabase; } });
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEMA
+// ═══════════════════════════════════════════════════════════════════════════
+var index_js_2 = require("./schema/index.js");
+// Decorators
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return index_js_2.Entity; } });
+Object.defineProperty(exports, "PrimaryKey", { enumerable: true, get: function () { return index_js_2.PrimaryKey; } });
+Object.defineProperty(exports, "AutoGenerate", { enumerable: true, get: function () { return index_js_2.AutoGenerate; } });
+Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_js_2.Index; } });
+Object.defineProperty(exports, "Unique", { enumerable: true, get: function () { return index_js_2.Unique; } });
+Object.defineProperty(exports, "Nullable", { enumerable: true, get: function () { return index_js_2.Nullable; } });
+Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return index_js_2.Default; } });
+// Relation decorators
+Object.defineProperty(exports, "HasMany", { enumerable: true, get: function () { return index_js_2.HasMany; } });
+Object.defineProperty(exports, "HasOne", { enumerable: true, get: function () { return index_js_2.HasOne; } });
+Object.defineProperty(exports, "BelongsTo", { enumerable: true, get: function () { return index_js_2.BelongsTo; } });
+Object.defineProperty(exports, "ManyToMany", { enumerable: true, get: function () { return index_js_2.ManyToMany; } });
+// Registry
+Object.defineProperty(exports, "SchemaRegistry", { enumerable: true, get: function () { return index_js_2.SchemaRegistry; } });
+Object.defineProperty(exports, "DB_METADATA_KEYS", { enumerable: true, get: function () { return index_js_2.DB_METADATA_KEYS; } });
+// ═══════════════════════════════════════════════════════════════════════════
+// QUERY
+// ═══════════════════════════════════════════════════════════════════════════
+var index_js_3 = require("./query/index.js");
+// Engine
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return index_js_3.QueryEngine; } });
+// ═══════════════════════════════════════════════════════════════════════════
+// STORAGE
+// ═══════════════════════════════════════════════════════════════════════════
+var index_js_4 = require("./storage/index.js");
+Object.defineProperty(exports, "MemoryStore", { enumerable: true, get: function () { return index_js_4.MemoryStore; } });
+Object.defineProperty(exports, "IndexManager", { enumerable: true, get: function () { return index_js_4.IndexManager; } });
+Object.defineProperty(exports, "IdGenerator", { enumerable: true, get: function () { return index_js_4.IdGenerator; } });
+Object.defineProperty(exports, "UniqueConstraintError", { enumerable: true, get: function () { return index_js_4.UniqueConstraintError; } });
+Object.defineProperty(exports, "EntityNotFoundError", { enumerable: true, get: function () { return index_js_4.EntityNotFoundError; } });
+Object.defineProperty(exports, "EntityAlreadyExistsError", { enumerable: true, get: function () { return index_js_4.EntityAlreadyExistsError; } });
+// Legacy provider (deprecated, use InMemoryDBProvider)
+var db_in_memory_provider_js_1 = require("./db-in-memory.provider.js");
+Object.defineProperty(exports, "InMemoryDataProvider", { enumerable: true, get: function () { return db_in_memory_provider_js_1.InMemoryDataProvider; } });
+Object.defineProperty(exports, "InMemoryDataTable", { enumerable: true, get: function () { return db_in_memory_provider_js_1.InMemoryDataTable; } });
+// Legacy errors (now exported from storage)
+var db_in_memory_types_js_1 = require("./db-in-memory.types.js");
+Object.defineProperty(exports, "LegacyEntityNotFoundError", { enumerable: true, get: function () { return db_in_memory_types_js_1.EntityNotFoundError; } });
+Object.defineProperty(exports, "LegacyEntityAlreadyExistsError", { enumerable: true, get: function () { return db_in_memory_types_js_1.EntityAlreadyExistsError; } });
+// Legacy base repository
+var base_repo_repository_js_1 = require("./base-repo.repository.js");
+Object.defineProperty(exports, "LegacyBaseRepository", { enumerable: true, get: function () { return base_repo_repository_js_1.BaseRepository; } });

package/lib/cjs/provider/db-in-memory/query/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Query Module Exports
+ * @module db-in-memory/query
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryEngine = void 0;
+__exportStar(require("./query.types.js"), exports);
+var query_engine_js_1 = require("./query-engine.js");
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return query_engine_js_1.QueryEngine; } });