@expressots/core 3.0.0 → 4.0.0-preview.3

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

@@ -0,0 +1,688 @@
+"use strict";
+/**
+ * In-Memory Adapter for ExpressoTS
+ *
+ * High-performance in-memory implementation of IDataAdapter
+ * with Prisma-compatible API.
+ *
+ * @module db-in-memory/adapter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryDatabase = exports.InMemoryAdapter = void 0;
+const decorators_js_1 = require("../schema/decorators.js");
+const node_require_js_1 = require("../../../utils/node-require.js");
+const memory_store_js_1 = require("../storage/memory-store.js");
+const query_engine_js_1 = require("../query/query-engine.js");
+/**
+ * High-performance in-memory implementation of IDataAdapter.
+ *
+ * Features:
+ * - Prisma-compatible query API
+ * - Secondary indexes for O(1) lookups
+ * - Automatic ID generation
+ * - Timestamps (createdAt, updatedAt)
+ * - Soft deletes
+ * - Transactions with rollback
+ * - Relation support
+ * - Reactive subscriptions
+ *
+ * @example
+ * ```typescript
+ * const userAdapter = new InMemoryAdapter<User>("users");
+ *
+ * // Create
+ * const user = await userAdapter.create({
+ *   data: { name: "John", email: "john@example.com" }
+ * });
+ *
+ * // Find with filters
+ * const adults = await userAdapter.findMany({
+ *   where: { age: { gte: 18 } },
+ *   orderBy: { name: "asc" }
+ * });
+ * ```
+ *
+ * @public API
+ */
+class InMemoryAdapter {
+    constructor(tableName, options = {}) {
+        this.subscribers = [];
+        this.typeSubscribers = new Map();
+        this.tableName = tableName;
+        this.database = options.database;
+        this.entityClass = options.entityClass;
+        this.store = new memory_store_js_1.MemoryStore(tableName, options);
+        this.queryEngine = new query_engine_js_1.QueryEngine(this.store);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // FIND OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    async findUnique(args) {
+        const { where, include } = args;
+        // Try to find by ID first (fastest)
+        if (where.id) {
+            const entity = this.store.findById(where.id);
+            if (entity) {
+                return this.resolveIncludes(entity, include);
+            }
+            return null;
+        }
+        // Find by other unique fields
+        const whereInput = where;
+        const entities = this.queryEngine.executeWhere(whereInput);
+        const entity = entities[0] || null;
+        if (entity && include) {
+            return this.resolveIncludes(entity, include);
+        }
+        return entity;
+    }
+    async findUniqueOrThrow(args) {
+        const result = await this.findUnique(args);
+        if (!result) {
+            throw new memory_store_js_1.EntityNotFoundError(this.tableName, args.where.id || JSON.stringify(args.where));
+        }
+        return result;
+    }
+    async findFirst(args) {
+        if (!args) {
+            const all = this.store.findAll();
+            return all[0] || null;
+        }
+        const { where, orderBy, skip, include } = args;
+        let entities = this.queryEngine.executeWhere(where);
+        entities = this.queryEngine.executeOrderBy(entities, orderBy);
+        entities = this.queryEngine.executePagination(entities, skip, 1);
+        const entity = entities[0] || null;
+        if (entity && include) {
+            return this.resolveIncludes(entity, include);
+        }
+        return entity;
+    }
+    async findFirstOrThrow(args) {
+        const result = await this.findFirst(args);
+        if (!result) {
+            throw new memory_store_js_1.EntityNotFoundError(this.tableName, "first match");
+        }
+        return result;
+    }
+    async findMany(args) {
+        const entities = this.queryEngine.executeFindMany(args);
+        if (args?.include) {
+            return Promise.all(entities.map((entity) => this.resolveIncludes(entity, args.include)));
+        }
+        return entities;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CREATE OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    async create(args) {
+        const entity = this.store.insert(args.data);
+        this.emit({ type: "create", data: entity, timestamp: new Date() });
+        if (args.include) {
+            return this.resolveIncludes(entity, args.include);
+        }
+        return entity;
+    }
+    async createMany(args) {
+        const entities = this.store.insertMany(args.data, args.skipDuplicates);
+        for (const entity of entities) {
+            this.emit({ type: "create", data: entity, timestamp: new Date() });
+        }
+        return { count: entities.length };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // UPDATE OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    async update(args) {
+        const existing = await this.findUnique({ where: args.where });
+        if (!existing) {
+            throw new memory_store_js_1.EntityNotFoundError(this.tableName, args.where.id || JSON.stringify(args.where));
+        }
+        const updated = this.store.update(existing.id, args.data);
+        this.emit({
+            type: "update",
+            data: updated,
+            previousData: existing,
+            timestamp: new Date(),
+        });
+        if (args.include) {
+            return this.resolveIncludes(updated, args.include);
+        }
+        return updated;
+    }
+    async updateMany(args) {
+        const entities = this.queryEngine.executeWhere(args.where);
+        let count = 0;
+        for (const entity of entities) {
+            const updated = this.store.update(entity.id, args.data);
+            this.emit({
+                type: "update",
+                data: updated,
+                previousData: entity,
+                timestamp: new Date(),
+            });
+            count++;
+        }
+        return { count };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // UPSERT OPERATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    async upsert(args) {
+        const existing = await this.findUnique({ where: args.where });
+        if (existing) {
+            return this.update({
+                where: args.where,
+                data: args.update,
+                select: args.select,
+                include: args.include,
+            });
+        }
+        return this.create({
+            data: args.create,
+            select: args.select,
+            include: args.include,
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // DELETE OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    async delete(args) {
+        const existing = await this.findUnique({ where: args.where });
+        if (!existing) {
+            throw new memory_store_js_1.EntityNotFoundError(this.tableName, args.where.id || JSON.stringify(args.where));
+        }
+        const deleted = this.store.delete(existing.id);
+        this.emit({
+            type: "delete",
+            previousData: deleted,
+            timestamp: new Date(),
+        });
+        return deleted;
+    }
+    async deleteMany(args) {
+        if (!args?.where) {
+            const count = this.store.count();
+            const all = this.store.findAll();
+            for (const entity of all) {
+                this.emit({
+                    type: "delete",
+                    previousData: entity,
+                    timestamp: new Date(),
+                });
+            }
+            this.store.clear();
+            return { count };
+        }
+        const entities = this.queryEngine.executeWhere(args.where);
+        let count = 0;
+        for (const entity of entities) {
+            this.store.delete(entity.id);
+            this.emit({
+                type: "delete",
+                previousData: entity,
+                timestamp: new Date(),
+            });
+            count++;
+        }
+        return { count };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // COUNT & AGGREGATE
+    // ═══════════════════════════════════════════════════════════════════════════
+    async count(args) {
+        if (!args) {
+            return this.store.count();
+        }
+        const entities = this.queryEngine.executeWhere(args.where);
+        return this.queryEngine.executePagination(entities, args.skip, args.take)
+            .length;
+    }
+    async aggregate(args) {
+        return this.queryEngine.executeAggregate(args);
+    }
+    async groupBy(args) {
+        let entities = this.queryEngine.executeWhere(args.where);
+        entities = this.queryEngine.executeOrderBy(entities, args.orderBy);
+        entities = this.queryEngine.executePagination(entities, args.skip, args.take);
+        // Group by specified fields
+        const groups = new Map();
+        for (const entity of entities) {
+            const key = args.by
+                .map((field) => JSON.stringify(entity[field]))
+                .join("|");
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(entity);
+        }
+        // Apply having filter and compute aggregates
+        const results = [];
+        for (const [, groupEntities] of groups) {
+            const representative = groupEntities[0];
+            // Build group key object
+            const groupKey = {};
+            for (const field of args.by) {
+                groupKey[field] =
+                    representative[field];
+            }
+            // Apply having filter
+            if (args.having) {
+                if (!this.queryEngine.matchesWhere(representative, args.having)) {
+                    continue;
+                }
+            }
+            // Compute aggregates for this group
+            const groupAggregates = {};
+            if (args._count) {
+                if (args._count === true) {
+                    groupAggregates._count = groupEntities.length;
+                }
+                else {
+                    groupAggregates._count = { _all: groupEntities.length };
+                }
+            }
+            if (args._avg) {
+                groupAggregates._avg = {};
+                for (const [field, include] of Object.entries(args._avg)) {
+                    if (include) {
+                        const values = groupEntities
+                            .map((e) => e[field])
+                            .filter((v) => typeof v === "number");
+                        groupAggregates._avg[field] =
+                            values.length > 0
+                                ? values.reduce((a, b) => a + b, 0) / values.length
+                                : null;
+                    }
+                }
+            }
+            if (args._sum) {
+                groupAggregates._sum = {};
+                for (const [field, include] of Object.entries(args._sum)) {
+                    if (include) {
+                        const values = groupEntities
+                            .map((e) => e[field])
+                            .filter((v) => typeof v === "number");
+                        groupAggregates._sum[field] =
+                            values.length > 0 ? values.reduce((a, b) => a + b, 0) : null;
+                    }
+                }
+            }
+            results.push({ ...groupKey, ...groupAggregates });
+        }
+        return results;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // TRANSACTIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    async transaction(fn) {
+        return this.store.transaction(async () => {
+            return fn(this);
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // RELATIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Resolve include clauses for relations.
+     * @private
+     */
+    async resolveIncludes(entity, include) {
+        if (!include || !this.database || !this.entityClass) {
+            return entity;
+        }
+        const relations = decorators_js_1.SchemaRegistry.getRelations(this.entityClass);
+        const result = { ...entity };
+        for (const [field, includeConfig] of Object.entries(include)) {
+            if (!includeConfig)
+                continue;
+            const relation = relations.find((r) => String(r.field) === field);
+            if (!relation)
+                continue;
+            const relatedData = await this.resolveRelation(entity, relation, includeConfig);
+            result[field] = relatedData;
+        }
+        return result;
+    }
+    /**
+     * Resolve a single relation.
+     * @private
+     */
+    async resolveRelation(entity, relation, includeConfig) {
+        if (!this.database)
+            return null;
+        const relatedEntityMeta = decorators_js_1.SchemaRegistry.getMetadata(relation.target());
+        if (!relatedEntityMeta)
+            return null;
+        const relatedAdapter = this.database.table(relatedEntityMeta.name);
+        switch (relation.type) {
+            case "hasMany": {
+                const foreignKeyValue = entity.id;
+                return relatedAdapter.findMany({
+                    where: {
+                        [relation.foreignKey]: foreignKeyValue,
+                    },
+                    ...(typeof includeConfig === "object" ? includeConfig : {}),
+                });
+            }
+            case "hasOne": {
+                const foreignKeyValue = entity.id;
+                return relatedAdapter.findFirst({
+                    where: {
+                        [relation.foreignKey]: foreignKeyValue,
+                    },
+                });
+            }
+            case "belongsTo": {
+                const foreignKeyValue = entity[relation.foreignKey];
+                if (!foreignKeyValue)
+                    return null;
+                return relatedAdapter.findUnique({
+                    where: { id: foreignKeyValue },
+                });
+            }
+            case "manyToMany": {
+                // Resolve through a join table. Convention: the `through` table holds
+                // link records with two foreign keys named `<sourceClass>Id` and
+                // `<targetClass>Id` (class names lowercased). For example, a
+                // Post <-> Tag relation through "post_tags" stores rows shaped like
+                // `{ postId, tagId }`.
+                if (!relation.through || !this.entityClass)
+                    return [];
+                const sourceKey = `${this.entityClass.name.toLowerCase()}Id`;
+                const targetKey = `${relation.target().name.toLowerCase()}Id`;
+                const joinAdapter = this.database.table(relation.through);
+                const joinRecords = await joinAdapter.findMany({
+                    where: { [sourceKey]: entity.id },
+                });
+                const targetIds = joinRecords
+                    .map((record) => record[targetKey])
+                    .filter((value) => typeof value === "string");
+                if (targetIds.length === 0)
+                    return [];
+                const related = await Promise.all(targetIds.map((id) => relatedAdapter.findUnique({ where: { id } })));
+                return related.filter((item) => item !== null);
+            }
+            default:
+                return null;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // REACTIVE SUBSCRIPTIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    subscribe(callback) {
+        this.subscribers.push(callback);
+        return {
+            unsubscribe: () => {
+                const index = this.subscribers.indexOf(callback);
+                if (index > -1) {
+                    this.subscribers.splice(index, 1);
+                }
+            },
+        };
+    }
+    on(type, callback) {
+        if (!this.typeSubscribers.has(type)) {
+            this.typeSubscribers.set(type, []);
+        }
+        this.typeSubscribers.get(type).push(callback);
+        return {
+            unsubscribe: () => {
+                const callbacks = this.typeSubscribers.get(type);
+                if (callbacks) {
+                    const index = callbacks.indexOf(callback);
+                    if (index > -1) {
+                        callbacks.splice(index, 1);
+                    }
+                }
+            },
+        };
+    }
+    emit(event) {
+        // Notify general subscribers
+        for (const callback of this.subscribers) {
+            try {
+                callback(event);
+            }
+            catch (error) {
+                console.error("Error in subscription callback:", error);
+            }
+        }
+        // Notify type-specific subscribers
+        const typeCallbacks = this.typeSubscribers.get(event.type);
+        if (typeCallbacks) {
+            for (const callback of typeCallbacks) {
+                try {
+                    callback(event);
+                }
+                catch (error) {
+                    console.error("Error in subscription callback:", error);
+                }
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // UTILITIES
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Clear all data in this table.
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Export table data as JSON.
+     * @returns JSON string
+     */
+    toJSON() {
+        return this.store.toJSON();
+    }
+    /**
+     * Import table data from JSON.
+     * @param json - JSON string
+     */
+    fromJSON(json) {
+        this.store.fromJSON(json);
+    }
+    /**
+     * Get table statistics.
+     * @returns Statistics object
+     */
+    getStats() {
+        return this.store.getStats();
+    }
+}
+exports.InMemoryAdapter = InMemoryAdapter;
+/**
+ * In-Memory Database with multi-table support.
+ *
+ * The main entry point for the in-memory database system.
+ * Provides a clean API for managing multiple tables with
+ * relation support.
+ *
+ * @example
+ * ```typescript
+ * const db = new InMemoryDatabase();
+ *
+ * // Access tables
+ * const users = db.table<User>("users");
+ * const posts = db.table<Post>("posts");
+ *
+ * // Create with relations
+ * const user = await users.create({
+ *   data: { name: "John", email: "john@example.com" }
+ * });
+ *
+ * const post = await posts.create({
+ *   data: { title: "Hello", authorId: user.id }
+ * });
+ *
+ * // Query with includes
+ * const userWithPosts = await users.findUnique({
+ *   where: { id: user.id },
+ *   include: { posts: true }
+ * });
+ * ```
+ *
+ * @public API
+ */
+class InMemoryDatabase {
+    constructor(options = {}) {
+        this.tables = new Map();
+        this.options = {
+            timestamps: true,
+            softDelete: false,
+            ...options,
+        };
+        // Setup auto-persist if configured
+        if (options.persist?.interval && options.persist.interval > 0) {
+            this.persistInterval = setInterval(() => this.snapshot(), options.persist.interval);
+        }
+    }
+    /**
+     * Get or create a table adapter.
+     * @param tableName - Name of the table
+     * @param entityClass - Optional entity class for schema metadata
+     * @returns Table adapter
+     */
+    table(tableName, entityClass) {
+        if (!this.tables.has(tableName)) {
+            this.tables.set(tableName, new InMemoryAdapter(tableName, {
+                database: this,
+                entityClass,
+                timestamps: this.options.timestamps,
+                softDelete: this.options.softDelete,
+                maxRecordsPerTable: this.options.maxRecordsPerTable,
+            }));
+        }
+        return this.tables.get(tableName);
+    }
+    /**
+     * Execute operations in a transaction across all tables.
+     * @param fn - Transaction function
+     * @returns Result of the transaction function
+     */
+    async transaction(fn) {
+        // Begin transaction on all tables
+        for (const adapter of this.tables.values()) {
+            adapter.store.beginTransaction();
+        }
+        try {
+            const result = await fn(this);
+            // Commit all
+            for (const adapter of this.tables.values()) {
+                adapter.store.commitTransaction();
+            }
+            return result;
+        }
+        catch (error) {
+            // Rollback all
+            for (const adapter of this.tables.values()) {
+                try {
+                    adapter.store.rollbackTransaction();
+                }
+                catch {
+                    // Ignore rollback errors
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create a snapshot of all data.
+     * @returns JSON string of all data
+     */
+    snapshot() {
+        const data = {};
+        for (const [name, adapter] of this.tables) {
+            data[name] = adapter.toJSON();
+        }
+        const json = JSON.stringify(data);
+        // Write to file if configured
+        if (this.options.persist?.storage === "file" && this.options.persist.path) {
+            this.writeToFile(this.options.persist.path, json);
+        }
+        return json;
+    }
+    /**
+     * Restore data from a snapshot.
+     * @param json - JSON string of snapshot data
+     */
+    restore(json) {
+        const data = JSON.parse(json);
+        for (const [name, tableJson] of Object.entries(data)) {
+            const adapter = this.table(name);
+            adapter.fromJSON(tableJson);
+        }
+    }
+    /**
+     * Load data from persistence storage.
+     */
+    async load() {
+        if (this.options.persist?.storage === "file" && this.options.persist.path) {
+            try {
+                const json = await this.readFromFile(this.options.persist.path);
+                this.restore(json);
+            }
+            catch {
+                // File doesn't exist or is invalid, start fresh
+            }
+        }
+    }
+    /**
+     * Clear all tables.
+     */
+    clear() {
+        for (const adapter of this.tables.values()) {
+            adapter.clear();
+        }
+    }
+    /**
+     * Get database statistics.
+     * @returns Statistics for all tables
+     */
+    getStats() {
+        const tables = Array.from(this.tables.values()).map((adapter) => adapter.getStats());
+        return {
+            tableCount: this.tables.size,
+            totalRecords: tables.reduce((sum, t) => sum + t.recordCount, 0),
+            tables,
+        };
+    }
+    /**
+     * Shutdown the database (cleanup).
+     */
+    shutdown() {
+        if (this.persistInterval) {
+            clearInterval(this.persistInterval);
+        }
+        // Final snapshot if persistence is enabled
+        if (this.options.persist) {
+            this.snapshot();
+        }
+    }
+    /**
+     * Write data to file (Node.js only).
+     * @private
+     */
+    writeToFile(path, data) {
+        try {
+            // Dynamic import via node-require helper so this works in both
+            // CJS and ESM compiled output.
+            const fs = (0, node_require_js_1.nodeRequire)("node:fs");
+            fs.writeFileSync(path, data, "utf-8");
+        }
+        catch (error) {
+            console.error("Failed to write snapshot to file:", error);
+        }
+    }
+    /**
+     * Read data from file (Node.js only).
+     * @private
+     */
+    async readFromFile(path) {
+        const fs = (0, node_require_js_1.nodeRequire)("node:fs");
+        return fs.readFileSync(path, "utf-8");
+    }
+}
+exports.InMemoryDatabase = InMemoryDatabase;

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Adapter Module Exports
+ * @module db-in-memory/adapter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryDatabase = exports.InMemoryAdapter = void 0;
+var in_memory_adapter_js_1 = require("./in-memory.adapter.js");
+Object.defineProperty(exports, "InMemoryAdapter", { enumerable: true, get: function () { return in_memory_adapter_js_1.InMemoryAdapter; } });
+Object.defineProperty(exports, "InMemoryDatabase", { enumerable: true, get: function () { return in_memory_adapter_js_1.InMemoryDatabase; } });