@static-suite/static-suite-data-server 0.0.1

package/dist/lib/query/queryManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryManager.d.ts","sourceRoot":"","sources":["../../../src/lib/query/queryManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,wEAAmD,CAAC"}

package/dist/lib/query/queryManager.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryManager = void 0;
+const module_1 = require("@lib/utils/module");
+/**
+ * A manager for queries stored in a user-land directory defined by configuration.
+ *
+ * @remarks
+ * It extends dirBasedModuleGroupManager, which manages groups of modules based
+ * on a directory: @see {@link dirBasedModuleGroupManager}
+ */
+exports.queryManager = (0, module_1.dirBasedModuleGroupManager)('query');

package/dist/lib/query/queryRunner copy.d.ts

@@ -0,0 +1,3 @@
+import { QueryRunner } from './query.types';
+export declare const queryRunner: QueryRunner;
+//# sourceMappingURL=queryRunner%20copy.d.ts.map

package/dist/lib/query/queryRunner copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryRunner copy.d.ts","sourceRoot":"","sources":["../../../src/lib/query/queryRunner copy.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,WAAW,EAIZ,MAAM,eAAe,CAAC;AAkBvB,eAAO,MAAM,WAAW,EAAE,WAiEzB,CAAC"}

package/dist/lib/query/queryRunner copy.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRunner = void 0;
+const microtime_1 = __importDefault(require("microtime"));
+const config_1 = require("@lib/config");
+const store_1 = require("@lib/store");
+const logger_1 = require("@lib/utils/logger");
+const cache_1 = require("@lib/utils/cache");
+const queryManager_1 = require("./queryManager");
+const query_types_1 = require("./query.types");
+let count = 0;
+/**
+ * Creates a QueryErrorResponse object ready to be returned to clients.
+ *
+ * @param message - Error message
+ *
+ * @returns A JSON object with an error key
+ *
+ * @internal
+ */
+const createErrorResponse = (message) => {
+    logger_1.logger.error(message);
+    return { error: message };
+};
+exports.queryRunner = {
+    run: (queryId, args) => {
+        if (!config_1.config.queryDir) {
+            return createErrorResponse('No query directory ("queryDir") configured');
+        }
+        if (!queryId) {
+            return createErrorResponse('No query ID received');
+        }
+        const queryModuleInfo = queryManager_1.queryManager.getModuleGroupInfo().get(queryId);
+        if (!queryModuleInfo) {
+            return createErrorResponse(`Query module for ID ${queryId} not found`);
+        }
+        count += 1;
+        const startDate = microtime_1.default.now();
+        const argsString = JSON.stringify(args);
+        // Implement a query cache.
+        const cacheId = `${queryId}--${argsString}`;
+        let isCacheMiss = false;
+        const queryCache = cache_1.cache.bin('query');
+        let queryResult = queryCache.get(cacheId);
+        if (!queryResult) {
+            try {
+                const queryModule = queryModuleInfo.getModule();
+                const queryResponse = queryModule.default({
+                    store: store_1.store,
+                    args,
+                });
+                queryResult = {
+                    result: queryResponse?.result,
+                    contentType: queryResponse?.contentType || 'application/json',
+                    tags: queryResponse?.tags,
+                };
+                isCacheMiss = true;
+                if (queryResponse?.cacheable !== false) {
+                    queryCache.set(cacheId, queryResult);
+                }
+            }
+            catch (e) {
+                // Log error and rethrow.
+                logger_1.logger.error(`#${count} Query error: "${queryId}", args "${argsString}": ${e}`);
+                throw e;
+            }
+        }
+        const execTimeMs = (microtime_1.default.now() - startDate) / 1000;
+        const response = {
+            data: queryResult.result,
+            metadata: {
+                contentType: queryResult?.contentType || 'application/json',
+                execTimeMs,
+                cache: isCacheMiss ? query_types_1.CacheStatus.MISS : query_types_1.CacheStatus.HIT,
+                tags: queryResult.tags,
+            },
+        };
+        /*     logger.debug(
+          `#${count} Query "${queryId}" args "${argsString}" took ${execTimeMs} ms.`,
+        ); */
+        return response;
+    },
+    getCount: () => count,
+};

package/dist/lib/query/queryRunner.d.ts

@@ -0,0 +1,3 @@
+import { QueryRunner } from './query.types';
+export declare const queryRunner: QueryRunner;
+//# sourceMappingURL=queryRunner.d.ts.map

package/dist/lib/query/queryRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryRunner.d.ts","sourceRoot":"","sources":["../../../src/lib/query/queryRunner.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,WAAW,EAKZ,MAAM,eAAe,CAAC;AAkBvB,eAAO,MAAM,WAAW,EAAE,WA4EzB,CAAC"}

package/dist/lib/query/queryRunner.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRunner = void 0;
+const microtime_1 = __importDefault(require("microtime"));
+const config_1 = require("@lib/config");
+const store_1 = require("@lib/store");
+const logger_1 = require("@lib/utils/logger");
+const cache_1 = require("@lib/utils/cache");
+const string_1 = require("@lib/utils/string");
+const dependencyTagger_1 = require("@lib/store/dependency/dependencyTagger");
+const queryManager_1 = require("./queryManager");
+const query_types_1 = require("./query.types");
+let count = 0;
+/**
+ * Creates a QueryErrorResponse object ready to be returned to clients.
+ *
+ * @param message - Error message
+ *
+ * @returns A JSON object with an error key
+ *
+ * @internal
+ */
+const createErrorResponse = (message) => {
+    logger_1.logger.error(message);
+    return { error: message };
+};
+exports.queryRunner = {
+    run: (queryDefinition) => {
+        if (!config_1.config.queryDir) {
+            return createErrorResponse('No query directory ("queryDir") configured');
+        }
+        const [queryId, queryArgsString] = queryDefinition.split('?');
+        const queryArgs = queryArgsString
+            ? (0, string_1.parseURLSearchParams)(queryArgsString)
+            : {};
+        if (!queryId) {
+            return createErrorResponse('No query ID received');
+        }
+        const queryModuleInfo = queryManager_1.queryManager.getModuleGroupInfo().get(queryId);
+        if (!queryModuleInfo) {
+            return createErrorResponse(`Query module for ID ${queryId} not found`);
+        }
+        count += 1;
+        const startDate = microtime_1.default.now();
+        // Implement a query cache.
+        const cacheId = queryDefinition;
+        let isCacheMiss = false;
+        const queryCache = cache_1.cache.bin('query');
+        let queryResult = queryCache.get(cacheId);
+        if (!queryResult) {
+            try {
+                const queryModule = queryModuleInfo.getModule();
+                const queryResponse = queryModule.default({
+                    store: store_1.store,
+                    args: queryArgs,
+                });
+                queryResult = {
+                    result: queryResponse?.result,
+                    contentType: queryResponse?.contentType || 'application/json',
+                };
+                isCacheMiss = true;
+                if (queryResponse?.cacheable !== false) {
+                    queryCache.set(cacheId, queryResult);
+                }
+                // Set tags for this query.
+                const queryTags = queryResponse.tags && queryResponse.tags?.length > 0
+                    ? queryResponse.tags
+                    : ['*'];
+                dependencyTagger_1.dependencyTagger.setDependency(queryDefinition, queryTags);
+            }
+            catch (e) {
+                // Log error and rethrow.
+                logger_1.logger.error(`#${count} Query error: "${queryId}", args "${queryArgsString}": ${e}`);
+                throw e;
+            }
+        }
+        const execTimeMs = (microtime_1.default.now() - startDate) / 1000;
+        const response = {
+            data: queryResult.result,
+            metadata: {
+                contentType: queryResult?.contentType || 'application/json',
+                execTimeMs,
+                cache: isCacheMiss ? query_types_1.CacheStatus.MISS : query_types_1.CacheStatus.HIT,
+                tags: queryResult.tags ? Array.from(queryResult.tags) : undefined,
+            },
+        };
+        /*     logger.debug(
+          `#${count} Query "${queryId}" args "${argsString}" took ${execTimeMs} ms.`,
+        ); */
+        return response;
+    },
+    getCount: () => count,
+};

package/dist/lib/query/queryTagManager.d.ts

@@ -0,0 +1,3 @@
+import { QueryTagManager } from './query.types';
+export declare const queryTagManager: QueryTagManager;
+//# sourceMappingURL=queryTagManager.d.ts.map

package/dist/lib/query/queryTagManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryTagManager.d.ts","sourceRoot":"","sources":["../../../src/lib/query/queryTagManager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAMhD,eAAO,MAAM,eAAe,EAAE,eA4C7B,CAAC"}

package/dist/lib/query/queryTagManager.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryTagManager = void 0;
+const store_1 = require("@lib/store/store");
+const invalidatedTags = new Set();
+const tagsByQueryIndex = new Map();
+exports.queryTagManager = {
+    invalidateTags: tags => {
+        tags.forEach(tag => {
+            invalidatedTags.add(tag);
+        });
+    },
+    resetInvalidatedTags: () => {
+        invalidatedTags.clear();
+    },
+    setTagsToQuery: (queryDefinition, tags) => {
+        if (tags) {
+            tagsByQueryIndex.set(queryDefinition, tags);
+        }
+        else {
+            tagsByQueryIndex.delete(queryDefinition);
+        }
+    },
+    getInvalidFilepaths: () => {
+        const invalidFilepaths = new Set();
+        store_1.store.data.forEach((json, relativeFilepath) => {
+            if (json?.metadata?.includes?.dynamic) {
+                Object.values(json.metadata.includes.dynamic).forEach(queryDefinition => {
+                    const tagsByQuery = tagsByQueryIndex.get(queryDefinition);
+                    if (tagsByQuery) {
+                        // eslint-disable-next-line no-restricted-syntax
+                        for (const invalidatedTag of invalidatedTags) {
+                            if (tagsByQuery.has(invalidatedTag)) {
+                                invalidFilepaths.add(relativeFilepath);
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        invalidFilepaths.add(relativeFilepath);
+                    }
+                });
+            }
+        });
+        return Array.from(invalidFilepaths);
+    },
+};

package/dist/lib/store/dataDir/dataDir.types.d.ts

@@ -0,0 +1,36 @@
+import { ChangedFiles } from '../workDir/workDir.types';
+/**
+ * A manager for the data dir from Static Suite.
+ */
+export declare type DataDirManager = {
+    /**
+     * Loads all files inside the data directory into the store.
+     *
+     */
+    load(): void;
+    /**
+     * Updates the store with changed files since last sync.
+     *
+     * @remarks
+     * It's main difference with load() is that, instead of loading the whole store,
+     * update() checks if something has changed, not doing anything if nothing
+     * has changed. Thus, this method is way faster than load().
+     *
+     * @returns A group of changed files in Static Suite's data dir.
+     */
+    update(): ChangedFiles;
+    /**
+     * Get date of last modification of data directory.
+     *
+     * @remarks
+     * Metadata about when and how is the data directory updated is
+     * stored in the work directory. If that directory is not present or
+     * not initialized with proper data, it returns the sync date of the store.
+     * If the store is not yet loaded, it returns a date in the past,
+     * the Unix Epoch (00:00:00 UTC on 1 January 1970).
+     *
+     * @returns The date of last modification of data directory
+     */
+    getModificationDate(): Date;
+};
+//# sourceMappingURL=dataDir.types.d.ts.map

package/dist/lib/store/dataDir/dataDir.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataDir.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dataDir/dataDir.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD;;GAEG;AACH,oBAAY,cAAc,GAAG;IAC3B;;;OAGG;IACH,IAAI,IAAI,IAAI,CAAC;IAEb;;;;;;;;;OASG;IACH,MAAM,IAAI,YAAY,CAAC;IAEvB;;;;;;;;;;;OAWG;IACH,mBAAmB,IAAI,IAAI,CAAC;CAC7B,CAAC"}

package/dist/lib/store/dataDir/dataDir.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/dataDir/dataDirManager.d.ts

@@ -0,0 +1,3 @@
+import { DataDirManager } from './dataDir.types';
+export declare const dataDirManager: DataDirManager;
+//# sourceMappingURL=dataDirManager.d.ts.map

package/dist/lib/store/dataDir/dataDirManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataDirManager.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dataDir/dataDirManager.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,eAAO,MAAM,cAAc,EAAE,cAyG5B,CAAC"}

package/dist/lib/store/dataDir/dataDirManager.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataDirManager = void 0;
+const microtime_1 = __importDefault(require("microtime"));
+const config_1 = require("@lib/config");
+const store_1 = require("@lib/store");
+const fs_1 = require("@lib/utils/fs");
+const logger_1 = require("@lib/utils/logger");
+const workDir_1 = require("@lib/store/workDir");
+const cache_1 = require("@lib/utils/cache");
+const storeManager_1 = require("@lib/store/storeManager");
+const hook_1 = require("@lib/store/hook");
+const query_1 = require("@lib/query");
+const task_1 = require("@lib/task");
+const dependencyManager_1 = require("../dependency/dependencyManager");
+exports.dataDirManager = {
+    load: () => {
+        logger_1.logger.info('Loading data dir...');
+        const startDate = Date.now();
+        // Reset store, just in case this load is called on an already loaded store.
+        storeManager_1.storeManager.reset();
+        // Clear all caches.
+        cache_1.cache.clear();
+        // Reset all managers.
+        hook_1.hookManager.reset();
+        query_1.queryManager.reset();
+        task_1.taskManager.reset();
+        // Invoke "store load start" hook.
+        hook_1.hookManager.invokeOnStoreLoadStart();
+        store_1.store.syncDate = exports.dataDirManager.getModificationDate();
+        // Add all files, one by one.
+        const relativeFilePaths = (0, fs_1.findFilesInDir)(config_1.config.dataDir);
+        const storeHydrationStartDate = Date.now();
+        relativeFilePaths.forEach(relativeFilePath => {
+            storeManager_1.storeManager.add(relativeFilePath);
+        });
+        logger_1.logger.debug(`Store map hydrated in ${Date.now() - storeHydrationStartDate}ms.`);
+        const includeParserStartDate = Date.now();
+        storeManager_1.storeManager.parseIncludes();
+        logger_1.logger.debug(`Store include parser done in ${Date.now() - includeParserStartDate}ms.`);
+        // Invoke "store load done" hook.
+        hook_1.hookManager.invokeOnStoreLoadDone();
+        logger_1.logger.info(`${relativeFilePaths.length} files loaded in ${Date.now() - startDate}ms.`);
+    },
+    update: () => {
+        const dataDirModificationDate = exports.dataDirManager.getModificationDate();
+        let changedFiles = {
+            updated: [],
+            deleted: [],
+        };
+        if (store_1.store.syncDate) {
+            if (dataDirModificationDate > store_1.store.syncDate) {
+                // Save store.syncDate to a variable and set it ASAP to avoid two concurrent
+                // processes updating the data directory at the same time.
+                const storeLastSyncDate = store_1.store.syncDate;
+                store_1.store.syncDate = dataDirModificationDate;
+                const startDate = microtime_1.default.now();
+                logger_1.logger.debug(`Data dir outdated. Current data loaded at ${storeLastSyncDate.toISOString()} but last updated at ${dataDirModificationDate.toISOString()}`);
+                // Before updating anything, track down which filepaths are invalidated with
+                // the current set of dependencies, before those dependencies change.
+                dependencyManager_1.dependencyManager.trackInvalidatedFilepaths();
+                changedFiles = workDir_1.workDirHelper.getChangedFilesSince(storeLastSyncDate);
+                hook_1.hookManager.invokeOnStoreChangeStart(changedFiles);
+                changedFiles.updated.forEach(file => {
+                    storeManager_1.storeManager.update(file);
+                    const fileContent = store_1.store.data.get(file);
+                    storeManager_1.storeManager.parseSingleFileIncludes(file, fileContent);
+                });
+                changedFiles.deleted.forEach(file => {
+                    storeManager_1.storeManager.remove(file);
+                });
+                // Clear all store subsets and queries, since they are stale.
+                // In fact, the subset cache should be cleared only when files
+                // are added or deleted, but not when they are simply updated.
+                // Anyway, we currently do not have any means of distinguishing
+                // added files from updated ones, so we must clear the subset
+                // cache in all situations.
+                cache_1.cache.bin('store-subset').clear();
+                cache_1.cache.bin('query').clear();
+                hook_1.hookManager.invokeOnStoreChangeDone(changedFiles);
+                const execTimeMs = (microtime_1.default.now() - startDate) / 1000;
+                logger_1.logger.debug(`Data dir updated in ${execTimeMs}ms.`);
+            }
+            else {
+                logger_1.logger.debug(`Data dir up to date. Current data loaded at ${store_1.store.syncDate.toISOString()} and last updated at ${dataDirModificationDate.toISOString()}`);
+            }
+        }
+        else {
+            logger_1.logger.debug(`Data dir not yet loaded, so it cannot be updated.`);
+        }
+        return changedFiles;
+    },
+    getModificationDate: () => workDir_1.workDirHelper.getModificationDate() || store_1.store.syncDate || new Date(0),
+};

package/dist/lib/store/dataDir/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dataDirManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/store/dataDir/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dataDir/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/lib/store/dataDir/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+__exportStar(require("./dataDirManager"), exports);

package/dist/lib/store/dependency/dependency.types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Service to define dependencies between data.
+ */
+export declare type DependencyTagger = {
+    /**
+     * Sets a dependency relationship between a tag that depends on another tags.
+     *
+     * @remarks It replaces any previous dependency relationship.
+     *
+     * @param tag - A tag to set a dependency for.
+     * @param dependsOnTags - An array of tags that depends on first parameter tag.
+     */
+    setDependency(tag: string, dependsOnTags: string[]): void;
+    /**
+     * Adds a dependency relationship between a tag that depends on another tags.
+     *
+     * @remarks It adds data to any previous dependency relationship.
+     *
+     * @param tag - A tag to set a dependency for.
+     * @param dependsOnTags - An array of tags that depends on first parameter tag.
+     */
+    addDependency(tag: string, dependsOnTags: string[]): void;
+    /**
+     * Deletes a dependency relationship between a tag that depends on another tags.
+     *
+     * @param tag - A tag to delete a dependency for.
+     * @param dependsOnTags - Optional array of tags that depends on first parameter
+     * tag. If not provided, it deletes all dependencies for tag.
+     */
+    deleteDependency(tag: string, dependsOnTags?: string[]): void;
+    /**
+     * Marks dependency items with any of the specified tags as invalid.
+     *
+     * @param tags - The list of tags for which to invalidate dependency items.
+     */
+    invalidateTags(tags: string[]): void;
+};
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+export declare type DependencyManager = {
+    /**
+     * Calculates and tracks down a list of filepaths which contain an invalidated tag.
+     *
+     * @remarks
+     * It calculates which filepaths have been invalidated, and stores them so they
+     * can be consumed later. This function should be called before the store is updated,
+     * before any dependency data changes, to avoid losing the set of invalidated filepaths
+     * between updates.
+     */
+    trackInvalidatedFilepaths(): void;
+    /**
+     * Gets a list of filepaths which contain an invalidated tag.
+     *
+     * @remarks
+     * It uses the set of tracked down filepaths from
+     *
+     * @returns A list of filepaths which contain an invalidated tag.
+     */
+    getInvalidatedFilepaths(): {
+        updated: string[];
+        deleted: string[];
+    };
+    /**
+     * Resets the list of invalidated tags once consumed.
+     */
+    reset(): void;
+};
+export declare type DependencyTree = Map<string, Set<string>>;
+//# sourceMappingURL=dependency.types.d.ts.map

package/dist/lib/store/dependency/dependency.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependency.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,gBAAgB,GAAG;IAC7B;;;;;;;OAOG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAE1D;;;;;;;OAOG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAE1D;;;;;;OAMG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAE9D;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAMtC,CAAC;AAEF;;GAEG;AACH,oBAAY,iBAAiB,GAAG;IAC9B;;;;;;;;OAQG;IACH,yBAAyB,IAAI,IAAI,CAAC;IAElC;;;;;;;OAOG;IACH,uBAAuB,IAAI;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAEpE;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,oBAAY,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/lib/store/dependency/dependency.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/dependency/dependencyFileHelper.d.ts

@@ -0,0 +1,6 @@
+import { Json } from '@lib/utils/object/object.types';
+export declare const dependencyIncludeHelper: {
+    setIncludeDependencies: (filepath: string, json: Json) => void;
+    deleteIncludeDependencies: (filepath: string, json: Json) => void;
+};
+//# sourceMappingURL=dependencyFileHelper.d.ts.map

package/dist/lib/store/dependency/dependencyFileHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyFileHelper.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependencyFileHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAGtD,eAAO,MAAM,uBAAuB;uCACC,MAAM,QAAQ,IAAI,KAAG,IAAI;0CA2BtB,MAAM,QAAQ,IAAI,KAAG,IAAI;CAkBhE,CAAC"}

package/dist/lib/store/dependency/dependencyFileHelper.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyIncludeHelper = void 0;
+const dependencyTagger_1 = require("./dependencyTagger");
+exports.dependencyIncludeHelper = {
+    setIncludeDependencies: (filepath, json) => {
+        const includes = json?.metadata?.includes;
+        if (includes?.static) {
+            const staticIncludes = Object.values(includes?.static);
+            dependencyTagger_1.dependencyTagger.setDependency(filepath, staticIncludes);
+        }
+        if (includes?.dynamic) {
+            const dynamicIncludes = Object.values(includes?.dynamic);
+            dependencyTagger_1.dependencyTagger.setDependency(filepath, dynamicIncludes);
+            // Queries are invalidated by any data change until they are executed,
+            // when they return their dependencies. They are "globally invalidable" when:
+            // 1) Are added for the first time
+            // 2) Are updated: file can contain another query include,
+            //    or different parameters, etc
+            // In another words:
+            // 1) When a file with a query is loaded for he first time,
+            //    that query has a dependency on "*"
+            // 2) When that query is executed, it has a dependency on "node:1234"
+            // 3) When that file with a query is updated, the query has again a dependency on "*"
+            dynamicIncludes.forEach(queryDefinition => {
+                dependencyTagger_1.dependencyTagger.setDependency(queryDefinition, ['*']);
+            });
+        }
+    },
+    deleteIncludeDependencies: (filepath, json) => {
+        const includes = json?.metadata?.includes;
+        if (includes?.static) {
+            const staticIncludes = Object.values(includes?.static);
+            dependencyTagger_1.dependencyTagger.deleteDependency(filepath, staticIncludes);
+        }
+        if (includes?.dynamic) {
+            const dynamicIncludes = Object.values(includes?.dynamic);
+            dependencyTagger_1.dependencyTagger.deleteDependency(filepath, dynamicIncludes);
+            // Queries are invalidated by any data change until they are executed,
+            // when they return their dependencies. Remove that dependency if still present.
+            dynamicIncludes.forEach(queryDefinition => {
+                dependencyTagger_1.dependencyTagger.deleteDependency(queryDefinition, ['*']);
+            });
+        }
+    },
+};

package/dist/lib/store/dependency/dependencyManager copy.d.ts

@@ -0,0 +1,6 @@
+import { DependencyManager } from './dependencyManager.types';
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+export declare const dependencyManager: DependencyManager;
+//# sourceMappingURL=dependencyManager%20copy.d.ts.map

package/dist/lib/store/dependency/dependencyManager copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyManager copy.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependencyManager copy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AA2C9D;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAsD/B,CAAC"}