joist-core 2.1.0 → 2.2.0-next.1

package/build/EntityManager.js

@@ -37,6 +37,7 @@ const findCountDataLoader_1 = require("./dataloaders/findCountDataLoader");
 const findDataLoader_1 = require("./dataloaders/findDataLoader");
 const findIdsDataLoader_1 = require("./dataloaders/findIdsDataLoader");
 const findOrCreateDataLoader_1 = require("./dataloaders/findOrCreateDataLoader");
+const findPaginatedDataLoader_1 = require("./dataloaders/findPaginatedDataLoader");
 const Entity_1 = require("./Entity");
 const FlushLock_1 = require("./FlushLock");
 const index_1 = require("./index");
@@ -48,6 +49,7 @@ const PluginManager_1 = require("./PluginManager");
 const ReactionsManager_1 = require("./ReactionsManager");
 const reactiveHints_1 = require("./reactiveHints");
 const relations_1 = require("./relations");
+const AsyncProperty_1 = require("./relations/AsyncProperty");
 const hasAsyncMethod_1 = require("./relations/hasAsyncMethod");
 const RecursiveCollection_1 = require("./relations/RecursiveCollection");
 const Todo_1 = require("./Todo");
@@ -246,7 +248,10 @@ class EntityManager {
     async find(type, where, options) {
         const { populate, ...rest } = options || {};
         const settings = { where, ...rest };
-        const result = await (0, findDataLoader_1.findDataLoader)(this, type, settings, populate)
+        const loader = hasPaginationSettings(rest)
+            ? (0, findPaginatedDataLoader_1.findPaginatedDataLoader)(this, type, settings, populate)
+            : (0, findDataLoader_1.findDataLoader)(this, type, settings, populate);
+        const result = await loader
             .load(settings)
             .catch(function find(err) {
             throw appendStack(err, new Error());
@@ -256,30 +261,51 @@ class EntityManager {
         }
         return result;
     }
-    async findPaginated(type, where, options) {
-        const { populate, limit, offset, ...rest } = options || {};
-        const meta = (0, index_1.getMetadata)(type);
-        const query = (0, index_1.parseFindQuery)(meta, where, rest);
-        const rows = await this.executeFind(meta, "findPaginated", query, { limit, offset });
-        // check row limit
-        const result = this.hydrate(type, rows);
-        if (populate) {
-            await this.populate(result, populate);
-        }
-        return result;
-    }
+    /** Runs the post-parse find pipeline: plugins mutate the logical AST, then Joist optimizes/prunes before SQL. */
     async executeFind(meta, operation, parsed, settings) {
+        const { checkLimit, driverSettings } = this.prepareFind(meta, operation, parsed, settings);
+        return this.executePreparedFind(meta, operation, parsed, driverSettings, checkLimit);
+    }
+    /** Executes a query that has already had find hooks and optimizations applied. */
+    async executePreparedFind(meta, operation, parsed, driverSettings, checkLimit) {
         const { pluginManager } = getEmInternalApi(this);
-        pluginManager.beforeFind(meta, operation, parsed, settings);
-        const rows = await this.driver.executeFind(this, parsed, settings);
+        const rows = await this.driver.executeFind(this, parsed, driverSettings);
+        // Check by default unless explicitly disabled or the caller removed the LIMIT via `limit: undefined`
+        const shouldCheck = checkLimit ?? !("limit" in driverSettings && driverSettings.limit === undefined);
+        if (shouldCheck && rows.length >= this.entityLimit) {
+            throw new Error(`Query returned more than ${this.entityLimit} entityLimit rows`);
+        }
         pluginManager.afterFind(meta, operation, rows);
         return rows;
     }
-    async findGql(type, where, options) {
-        return this.find(type, where, options);
+    /**
+     * Runs pre-SQL find hooks and optimizations against a parsed query.
+     *
+     * This allows plugins to see "pre-batched" / "logical" query ASTs, instead of our
+     * more complicated `_find` batched queries. The flow would be:
+     *
+     * - A loader calls `prepareFind(originalQuery)`
+     * - Plugins inspect/modify the query as/if needed
+     * - The loader crafts a new, more complicated query that embeds the originalQuery
+     * - The loader calls `executePreparedFind` with the 2nd query
+     */
+    prepareFind(meta, operation, parsed, settings) {
+        const { checkLimit, ...driverSettings } = settings;
+        const { pluginManager } = getEmInternalApi(this);
+        pluginManager.beforeFind(meta, operation, parsed, driverSettings);
+        (0, index_1.optimizeCollectionJoins)(parsed, settings);
+        return { checkLimit, driverSettings };
     }
-    async findGqlPaginated(type, where, options) {
-        return this.findPaginated(type, where, options);
+    async findGql(type, where, options) {
+        if (!options) {
+            return this.find(type, where);
+        }
+        const normalized = { ...options };
+        if ("limit" in normalized)
+            normalized.limit = normalized.limit ?? undefined;
+        if ("offset" in normalized)
+            normalized.offset = normalized.offset ?? undefined;
+        return this.find(type, where, normalized);
     }
     async findOne(type, where, options) {
         const list = await this.find(type, where, options);
@@ -878,11 +904,11 @@ class EntityManager {
             const createdThenDeleted = new Set();
             // We'll only invoke hooks once/entity (the 1st time that entity goes through runHooksOnPendingEntities)
             const hooksInvoked = new Set();
-            // Make sure two ReactiveQueryFields don't ping-pong each other forever
+            // Make sure two AsyncReactiveFields don't ping-pong each other forever
             let hookLoops = 0;
             let now = getNow();
             const suppressedDefaultTypeErrors = [];
-            // Make a lambda that we can invoke multiple times, if we loop for ReactiveQueryFields
+            // Make a lambda that we can invoke multiple times, if we loop for AsyncReactiveFields
             const runHooksOnPendingEntities = async () => {
                 if (hookLoops++ >= 10)
                     throw new Error("runHooksOnPendingEntities has ran 10 iterations, aborting");
@@ -899,18 +925,18 @@ class EntityManager {
                 // Subset of pendingFlush entities that had hooks invoked in a prior `runHooksOnPendingEntities`
                 const alreadyRanHooks = new Set();
                 findPendingFlushEntities(this.entities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
-                // If we're re-looping for ReactiveQueryField, make sure to bump updatedAt
+                // If we're re-looping for AsyncReactiveField, make sure to bump updatedAt
                 // each time, so that for an INSERT-then-UPDATE the triggers don't think the
                 // UPDATE forgot to self-bump updatedAt, and then "helpfully" bump it for us.
                 if (alreadyRanHooks.size > 0) {
-                    maybeBumpUpdatedAt((0, Todo_1.createTodos)([...alreadyRanHooks]), now);
+                    maybeBumpUpdatedAt(this.#rm, (0, Todo_1.createTodos)([...alreadyRanHooks]), now);
                 }
                 // Run hooks in a series of loops until things "settle down"
                 while (pendingHooks.size > 0) {
                     await this.#fl.allowWrites(async () => {
                         let todos = (0, Todo_1.createTodos)([...pendingHooks]);
                         await (0, defaults_1.setAsyncDefaults)(suppressedDefaultTypeErrors, this.ctx, Todo_1.Todo.groupInsertsByTypeAndSubType(todos));
-                        maybeBumpUpdatedAt(todos, now);
+                        maybeBumpUpdatedAt(this.#rm, todos, now);
                         // Run our hooks
                         for (const group of maybeSetupHookOrdering(todos)) {
                             await beforeCreate(this.ctx, group);
@@ -955,24 +981,30 @@ class EntityManager {
                     return !createThenDelete;
                 });
             };
-            const runValidation = async (entityTodos, joinRowTodos) => {
+            const { pluginManager } = getEmInternalApi(this);
+            const runValidation = async (entityTodos, joinRowTodos, validate) => {
+                const changedEntities = entitiesFromTodos(entityTodos, joinRowTodos);
                 try {
                     this.#isValidating = true;
-                    // Run simple rules first b/c it includes not-null/required rules, so that then when we run
-                    // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
-                    await validateSimpleRules(entityTodos);
-                    // After we've let any "author is not set" simple rules fail before prematurely throwing
-                    // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
-                    // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
-                    // that the user should see.
-                    if (suppressedDefaultTypeErrors.length > 0)
-                        throw suppressedDefaultTypeErrors[0];
-                    await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
+                    await pluginManager.beforeValidate(changedEntities);
+                    if (validate) {
+                        // Run simple rules first b/c it includes not-null/required rules, so that then when we run
+                        // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
+                        await validateSimpleRules(entityTodos);
+                        // After we've let any "author is not set" simple rules fail before prematurely throwing
+                        // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
+                        // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
+                        // that the user should see.
+                        if (suppressedDefaultTypeErrors.length > 0)
+                            throw suppressedDefaultTypeErrors[0];
+                        await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
+                        await afterValidation(this.ctx, entityTodos);
+                    }
+                    await pluginManager.afterValidate(changedEntities);
                 }
                 finally {
                     this.#isValidating = false;
                 }
-                await afterValidation(this.ctx, entityTodos);
             };
             // Run hooks (in iterative loops if hooks mutate new entities) on pending entities
             let entitiesToFlush = await runHooksOnPendingEntities();
@@ -982,13 +1014,10 @@ class EntityManager {
             // the full set of entities that will be INSERT/UPDATE/DELETE-d in the database.
             let entityTodos = (0, Todo_1.createTodos)(entitiesToFlush);
             let joinRowTodos = (0, Todo_1.combineJoinRows)(this.#joinRows);
-            if (!skipValidation) {
-                await runValidation(entityTodos, joinRowTodos);
-            }
+            await runValidation(entityTodos, joinRowTodos, !skipValidation);
             this.#rm.throwIfAnySuppressedTypeErrors();
             if (suppressedDefaultTypeErrors.length > 0)
                 throw suppressedDefaultTypeErrors[0];
-            const { pluginManager } = getEmInternalApi(this);
             if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
                 // The driver will handle the right thing if we're already in an existing transaction.
                 await this.driver.transaction(this, async () => {
@@ -1009,7 +1038,7 @@ class EntityManager {
                             // Actually do the recalc
                             await this.#fl.allowWrites(async () => {
                                 await this.#rm.recalcPendingReactables("reactiveQueries");
-                                // If any ReactiveFields depended on ReactiveQueryFields, go ahead and calc those now
+                                // If any ReactiveFields depended on AsyncReactiveFields, go ahead and calc those now
                                 await this.#rm.recalcPendingReactables("reactables");
                             });
                             // Advance `now` so that our triggers don't think our UPDATEs are forgetting to self-bump
@@ -1022,7 +1051,7 @@ class EntityManager {
                             // Recreate `entityTodos` against the only-the-just-changed entities
                             entityTodos = (0, Todo_1.createTodos)(entitiesToFlush);
                             joinRowTodos = (0, Todo_1.combineJoinRows)(this.#joinRows);
-                            await runValidation(entityTodos, joinRowTodos);
+                            await runValidation(entityTodos, joinRowTodos, true);
                             this.#rm.throwIfAnySuppressedTypeErrors();
                         }
                         else {
@@ -1044,6 +1073,11 @@ class EntityManager {
                     if (e.isNewEntity && !e.isDeletedEntity)
                         this.#entitiesById.set(e.idTagged, e);
                     (0, BaseEntity_1.getInstanceData)(e).resetAfterFlushed();
+                    // Reset AsyncQueryProperties since DB state may have changed
+                    for (const rel of Object.values((0, BaseEntity_1.getInstanceData)(e).relations)) {
+                        if (rel instanceof AsyncProperty_1.AsyncPropertyImpl)
+                            rel.resetAfterFlush();
+                    }
                 }
                 // Update the joinRows refs to reflect the new state
                 for (const joinRow of Object.values(joinRowTodos)) {
@@ -1251,7 +1285,7 @@ class EntityManager {
             (0, fields_1.setField)(entity, field.fieldName, entity[field.fieldName]);
         }));
         // `.load()` recalculated the immediate relations, go ahead and recalc any downstream reactables.
-        // We'll still defer ReactiveQueryFields to the em.flush loop.
+        // We'll still defer AsyncReactiveFields to the em.flush loop.
         await this.#rm.recalcPendingReactables("reactables");
     }
     beforeBegin(fn) {
@@ -1859,6 +1893,19 @@ function beforeUpdate(ctx, todos) {
 function afterValidation(ctx, todos) {
     return runHookOnTodos(ctx, "afterValidation", todos, ["inserts", "updates"]);
 }
+/** Collects changed entities from flush todos, i.e. m2m endpoint entities. */
+function entitiesFromTodos(entityTodos, joinRowTodos) {
+    const entities = new Set();
+    for (const todo of Object.values(entityTodos)) {
+        [...todo.inserts, ...todo.updates, ...todo.deletes].forEach((entity) => entities.add(entity));
+    }
+    for (const todo of Object.values(joinRowTodos)) {
+        [...todo.newRows, ...todo.deletedRows].forEach((row) => {
+            Object.values(row.columns).forEach((entity) => entities.add(entity));
+        });
+    }
+    return [...entities];
+}
 function beforeCommit(ctx, entities) {
     return runHook(ctx, "beforeCommit", [...entities]);
 }
@@ -1986,7 +2033,7 @@ function getCascadeDeleteRelations(entity) {
 function isCustomRelation(r) {
     return r instanceof index_1.CustomCollection || r instanceof index_1.CustomReference || r instanceof relations_1.ReactiveReferenceImpl;
 }
-function maybeBumpUpdatedAt(todos, now) {
+function maybeBumpUpdatedAt(rm, todos, now) {
     for (const todo of Object.values(todos)) {
         const { updatedAt } = todo.metadata.timestampFields ?? {};
         if (updatedAt) {
@@ -1999,6 +2046,7 @@ function maybeBumpUpdatedAt(todos, now) {
                 orm.originalData[updatedAt] = (0, fields_1.getField)(e, updatedAt);
                 const serde = todo.metadata.fields[updatedAt].serde;
                 orm.data[updatedAt] = serde.mapFromNow(now);
+                rm.queueDownstreamReactables(e, updatedAt);
             }
         }
     }
@@ -2074,6 +2122,10 @@ function findPendingFlushEntities(entities, hooksInvoked, pendingFlush, pendingH
         }
     }
 }
+/** Returns true if the caller explicitly asked `find` to use SQL pagination. */
+function hasPaginationSettings(options) {
+    return "limit" in options || "offset" in options;
+}
 /** An error we throw to get knex to `ROLLBACK`, but then catch. */
 class InMemoryRollbackError extends Error {
 }