@warlock.js/core 1.0.20 → 1.0.22

package/cjs/repositories/repository-list-manager.js

@@ -0,0 +1,747 @@
+'use strict';var cache=require('@warlock.js/cache'),cascade=require('@warlock.js/cascade'),injectRequestContext=require('../http/middleware/inject-request-context.js'),baseRepositoryManager=require('./base-repository-manager.js'),repositoryListing=require('./repository-listing.js'),utils=require('./utils.js');class RepositoryListManager extends baseRepositoryManager.BaseRepositoryManager {
+    /**
+     * List default options
+     */
+    defaultOptions = {};
+    /**
+     * Simple selected columns
+     */
+    simpleSelectColumns = ["id"];
+    /**
+     * Default filters list
+     */
+    defaultFilters = {
+        id: "int",
+        ids: ["inInt", "id"],
+        except: (id, query) => {
+            if (Array.isArray(id)) {
+                query.whereNotIn("id", id.map(Number));
+            }
+            else {
+                query.where("id", "!=", Number(id));
+            }
+        },
+        createdBy: ["int", "createdBy.id"],
+        isActive: "boolean",
+        simple: (_value, query) => {
+            query.select(this.simpleSelectColumns);
+        },
+    };
+    /**
+     * Filter By options
+     */
+    filterBy = {};
+    /**
+     * List of repositories that should clear its cache when this repository is created, updated or deleted
+     */
+    clearCacheOnUpdate = [];
+    /**
+     * Whether to enable caching
+     */
+    isCacheable = true;
+    /**
+     * Cache driver
+     */
+    cacheDriver = cache.cache;
+    /**
+     * Set the cache driver name
+     * If set, then it will be used instead of the default value in this.cacheDriver
+     */
+    cacheDriverName = "";
+    /**
+     * Define the `isActive` column
+     *
+     * @default isActive
+     */
+    isActiveColumn = "isActive";
+    /**
+     * Define the value of the `isActive` column when the record is active
+     *
+     * @default true
+     */
+    isActiveValue = true;
+    /**
+     * Constructor
+     */
+    constructor() {
+        super();
+        this.prepareCache();
+    }
+    /**
+     * Get active column and its value
+     */
+    getIsActiveFilter() {
+        return {
+            [this.isActiveColumn]: this.isActiveValue,
+        };
+    }
+    /**
+     * Set cache driver
+     */
+    setCacheDriver(driver) {
+        this.cacheDriver = driver;
+        return this;
+    }
+    /**
+     * Get cache driver
+     */
+    getCacheDriver() {
+        return this.cacheDriver;
+    }
+    /**
+     * List All records
+     */
+    async all(options = {}) {
+        return (await this.list({ ...options, paginate: false })).documents;
+    }
+    /**
+     * Get all cached data
+     */
+    async allCached(options) {
+        return await this.cacheAll({ options, purge: options?.purgeCache });
+    }
+    /**
+     * List All Active records
+     */
+    async allActive(options) {
+        return (await this.listActive({ ...options, paginate: false })).documents;
+    }
+    /**
+     * List all active cached records
+     */
+    async allActiveCached(options) {
+        return await this.cacheAll({
+            options: { ...options, ...this.getIsActiveFilter() },
+            purge: options?.purgeCache,
+        });
+    }
+    /**
+     * Prepare  cache
+     */
+    async prepareCache() {
+        if (!this.cacheDriver || !this.isCacheable)
+            return;
+        if (this.cacheDriverName) {
+            this.cacheDriver = await cache.cache.driver(this.cacheDriverName);
+        }
+        setTimeout(() => {
+            if (!this.model)
+                console.log(this);
+            this.model
+                .events()
+                .onSaved(async (model) => {
+                this.clearCache();
+                this.cacheModel(model);
+                for (const repository of this.clearCacheOnUpdate) {
+                    repository.clearCache();
+                }
+            })
+                .onDeleted(() => {
+                this.clearCache();
+                for (const repository of this.clearCacheOnUpdate) {
+                    repository.clearCache();
+                }
+            });
+        }, 0);
+    }
+    /**
+     * Cache the given model
+     */
+    async cacheModel(model) {
+        const cacheKey = this.cacheKey(`id.${model.id}`);
+        await this.cache(cacheKey, model.data);
+    }
+    /**
+     * Clear the entire cache
+     */
+    async clearCache() {
+        await this.cacheDriver.removeNamespace(this.cacheKey(""));
+    }
+    /**
+     * Before listing
+     * Called before listing records
+     */
+    async beforeListing(_query, _options) {
+        // override this method
+    }
+    /**
+     * On list
+     * Called after listing records
+     */
+    async onList(records) {
+        return records;
+    }
+    /**
+     * Merge default options with the given options
+     */
+    withDefaultOptions(options) {
+        return { ...utils.defaultRepositoryOptions, ...options };
+    }
+    /**
+     * Add default filters along side with the given filters
+     */
+    withDefaultFilters(filters = {}) {
+        return { ...this.defaultFilters, ...filters };
+    }
+    /**
+     * Get new query
+     */
+    newQuery() {
+        return this.model.aggregate();
+    }
+    /**
+     * An alias to newQuery
+     */
+    get query() {
+        return this.model.aggregate();
+    }
+    /**
+     * Get cached model
+     */
+    async getCachedModel(id) {
+        return this.getCachedModelBy("id", Number(id));
+    }
+    /**
+     * Get cached model by the given column
+     */
+    async getCachedModelBy(column, value, cacheKeyOptions) {
+        const cacheKey = this.cacheKey("data." + column + "." + value, cacheKeyOptions);
+        const cachedModel = await this.cacheDriver.get(cacheKey);
+        if (cachedModel) {
+            return cachedModel;
+        }
+        const model = await this.findBy(column, value);
+        if (!model)
+            return null;
+        this.cache(cacheKey, await model);
+        return model;
+    }
+    /**
+     * Get cached model data
+     */
+    async getCached(id) {
+        return this.getCachedBy("id", Number(id));
+    }
+    /**
+     * Get active cached model
+     */
+    async getActiveCached(id) {
+        const model = await this.getCached(id);
+        if (!model)
+            return null;
+        if (model.get(this.isActiveColumn) !== this.isActiveValue)
+            return null;
+        return model;
+    }
+    /**
+     * Generate cache key
+     */
+    cacheKey(key, moreOptions) {
+        let cacheKey = "repositories." + this.model.collection;
+        if (key) {
+            cacheKey += "." + JSON.stringify(key);
+        }
+        if (moreOptions) {
+            cacheKey += "." + JSON.stringify(moreOptions);
+        }
+        return cacheKey;
+    }
+    /**
+     * Get cached data by the given column
+     */
+    async getCachedBy(column, value, cacheKeyOptions) {
+        const { request } = injectRequestContext.useRequestStore() || {};
+        const localeCode = request.locale ? `locale.${request.locale}.` : "";
+        const cacheKey = this.cacheKey(`data.${localeCode}${column}.${value}`, cacheKeyOptions);
+        const cachedModel = await this.cacheDriver.get(cacheKey);
+        if (cachedModel) {
+            return this.newModel(cachedModel);
+        }
+        const model = await this.findBy(column, value);
+        if (!model)
+            return null;
+        this.cache(cacheKey, model.data);
+        return model;
+    }
+    /**
+     * Get and cached value by id then purge it from cache
+     */
+    async getCachedPurge(id) {
+        return this.getCachedByPurge("id", Number(id));
+    }
+    /**
+     * Get and cached by the given column then purge it from cache
+     */
+    async getCachedByPurge(column, value) {
+        const model = await this.getCachedBy(column, value);
+        if (!model)
+            return null;
+        this.clearCache();
+        return model;
+    }
+    /**
+     * List records
+     */
+    async list(options) {
+        const repositoryListing = this.newList(options);
+        await repositoryListing.list();
+        return {
+            documents: repositoryListing.documents,
+            paginationInfo: repositoryListing.paginationInfo,
+        };
+    }
+    /**
+     * Find latest records
+     */
+    async latest(options) {
+        return await this.list({
+            ...options,
+            orderBy: ["id", "desc"],
+        });
+    }
+    /**
+     * Get latest and active records
+     */
+    async latestActive(options) {
+        return await this.list({
+            ...this.getIsActiveFilter(),
+            ...options,
+            orderBy: ["id", "desc"],
+        });
+    }
+    /**
+     * Get oldest records
+     */
+    async oldest(options) {
+        return await this.list({
+            ...options,
+            orderBy: ["id", "asc"],
+        });
+    }
+    /**
+     * Get oldest and active records
+     */
+    async oldestActive(options) {
+        return await this.list({
+            ...this.getIsActiveFilter(),
+            ...options,
+            orderBy: ["id", "asc"],
+        });
+    }
+    /**
+     * List cached records
+     */
+    async listCached(options = {}) {
+        if (options.cacheCurrentLocale !== false) {
+            const localeCode = injectRequestContext.useRequestStore()?.request?.locale;
+            if (localeCode) {
+                if (!options) {
+                    options = {};
+                }
+                options.locale = localeCode;
+            }
+        }
+        return this.cacheList({
+            options,
+            cacheKey: options.cacheKey,
+            purge: options.purgeCache,
+        });
+    }
+    /**
+     * Fetch cached records or cache new ones
+     */
+    async cacheList({ cacheKey = "list", options, purge, expiresAfter, }) {
+        if (!this.isCacheable)
+            return this.list(options);
+        // generate cache key for the list method
+        cacheKey = this.cacheKey(cacheKey, options);
+        // check if the data is already cached
+        const listing = await this.cacheDriver.get(cacheKey);
+        if (listing) {
+            if (purge) {
+                this.cacheDriver.remove(cacheKey);
+            }
+            return {
+                documents: this.mapModels(listing.documents),
+                paginationInfo: listing.paginationInfo,
+            };
+        }
+        // if we reached here then the data is not cached yet, so we need to fetch it from database first
+        const { documents, paginationInfo } = await this.list(options);
+        if (!purge) {
+            const cachedDocuments = documents.map(document => document.data);
+            // cache the data
+            // please note that models can not be serialized, thus we need to store only the document data itself
+            this.cacheDriver.set(cacheKey, {
+                documents: cachedDocuments,
+                paginationInfo,
+            }, expiresAfter);
+        }
+        return {
+            documents: documents,
+            paginationInfo: paginationInfo,
+        };
+    }
+    /**
+     * Fetch cached records or cache new ones
+     */
+    async cacheAll({ key = "all", options, expiresAfter, purge, }) {
+        // generate cache key for the list method
+        const cacheKey = this.cacheKey(key, options);
+        // check if the data is already cached
+        const listing = await this.cacheDriver.get(cacheKey);
+        if (listing) {
+            if (purge) {
+                this.cacheDriver.remove(cacheKey);
+            }
+            return this.mapModels(listing);
+        }
+        // if we reached here then the data is not cached yet, so we need to fetch it from database first
+        const documents = await this.all(options);
+        if (!purge) {
+            const cachedDocuments = documents.map(document => document.data);
+            // cache the data
+            // please note that models can not be serialized, thus we need to store only the document data itself
+            this.cacheDriver.set(cacheKey, cachedDocuments, expiresAfter);
+        }
+        return documents;
+    }
+    /**
+     * Get new repository listing instance
+     */
+    newList(options) {
+        if (!this.filterBy.id) {
+            this.filterBy.id = "int";
+        }
+        const listing = new repositoryListing.RepositoryListing(this, this.filterBy, {
+            ...this.defaultOptions,
+            ...(options || {}),
+        });
+        if (this.dateFormat) {
+            listing.setDateFormat(this.dateFormat);
+        }
+        if (this.dateTimeFormat) {
+            listing.setDateTimeFormat(this.dateTimeFormat);
+        }
+        return listing;
+    }
+    /**
+     * Map the given documents into models
+     */
+    mapModels(documents) {
+        return documents.map(document => this.newModel(document));
+    }
+    /**
+     * Count total records based on the given options
+     */
+    async count(options = {}) {
+        const repositoryListing = this.newList(options);
+        return await repositoryListing.count();
+    }
+    /**
+     * Count total active records
+     */
+    async countActive(options = {}) {
+        return await this.count({
+            ...this.getIsActiveFilter(),
+            ...options,
+        });
+    }
+    /**
+     * Get total records based on the given options and cache it
+     */
+    async countCached(options = {}) {
+        const localeCode = injectRequestContext.useRequestStore()?.request?.locale;
+        if (localeCode) {
+            if (!options) {
+                options = {};
+            }
+            options.locale = localeCode;
+        }
+        const cacheKey = this.cacheKey("count", options);
+        let count = await this.cacheDriver.get(cacheKey);
+        if (options?.purgeCache) {
+            this.cacheDriver.remove(cacheKey);
+        }
+        if (count !== undefined) {
+            return count;
+        }
+        count = await this.count(options);
+        if (!options.purgeCache) {
+            this.cache(cacheKey, count);
+        }
+        return count;
+    }
+    /**
+     * Count active records and cache it
+     */
+    async countActiveCached(options = {}) {
+        return await this.countCached({
+            ...this.getIsActiveFilter(),
+            ...options,
+        });
+    }
+    /**
+     * Cache the given key and value
+     */
+    async cache(key, value) {
+        return await this.cacheDriver.set(key, value);
+    }
+    /**
+     * List active cached records
+     */
+    async listActiveCached(options = {}) {
+        return this.listCached({
+            ...this.getIsActiveFilter(),
+            ...options,
+        });
+    }
+    /**
+     * List active records
+     */
+    async listActive(options = {}) {
+        return this.list({
+            ...this.getIsActiveFilter(),
+            ...options,
+        });
+    }
+    /**
+     * Chunk records
+     */
+    async chunk(options, callback) {
+        //
+        if (!options.limit &&
+            !this.defaultOptions.defaultLimit &&
+            !this.defaultOptions.limit) {
+            throw new Error("limit is missing in the chunk method, please pass it to the options or define it in this.options object");
+        }
+        const query = this.newList(options);
+        return await query.chunk(callback);
+    }
+    /**
+     * Chunk active records
+     */
+    async chunkActive(options, callback) {
+        return await this.chunk({
+            ...this.getIsActiveFilter(),
+            ...options,
+        }, callback);
+    }
+    /**
+     * Get active record
+     */
+    async getActive(id, options = {}) {
+        return this.first({
+            ...this.getIsActiveFilter(),
+            perform(query) {
+                query.where("id", Number(id));
+            },
+            ...options,
+        });
+    }
+    /**
+     * Get single record by id
+     */
+    async get(id, options = {}) {
+        return this.first({
+            perform(query) {
+                query.where("id", Number(id));
+            },
+            ...options,
+        });
+    }
+    /**
+     * Get owned record
+     */
+    async getOwned(userId, id, column = "createdBy") {
+        return await this.first({
+            perform(query) {
+                query.where({
+                    id: Number(id),
+                    [`${column}.id`]: userId,
+                });
+            },
+        });
+    }
+    /**
+     * Get owned records
+     */
+    async listOwned(userId, options = {}, column = "createdBy") {
+        return await this.list({
+            ...options,
+            perform(query) {
+                query.where(`${column}.id`, Number(userId));
+            },
+        });
+    }
+    /**
+     * Get owned active records
+     */
+    async listOwnedActive(userId, options = {}, column = "createdBy") {
+        return await this.list({
+            ...options,
+            ...this.getIsActiveFilter(),
+            perform(query) {
+                query.where(`${column}.id`, userId);
+            },
+        });
+    }
+    /**
+     * Get first record
+     */
+    async first(options) {
+        const { documents } = await this.list({
+            orderBy: ["id", "asc"],
+            ...options,
+            limit: 1,
+        });
+        return documents[0] ?? null;
+    }
+    /**
+     * Get first cached record
+     */
+    async firstCached(options) {
+        const { documents } = await this.listCached({
+            orderBy: ["id", "asc"],
+            ...options,
+            limit: 1,
+        });
+        return documents[0] ?? null;
+    }
+    /**
+     * Get first active record
+     */
+    async firstActive(options) {
+        const { documents } = await this.listActive({
+            orderBy: ["id", "asc"],
+            ...options,
+            limit: 1,
+        });
+        return documents[0] ?? null;
+    }
+    /**
+     * Get first active cached record
+     */
+    async firstActiveCached(options) {
+        const { documents } = await this.listActiveCached({
+            orderBy: ["id", "asc"],
+            ...options,
+            limit: 1,
+        });
+        return documents[0] ?? null;
+    }
+    /**
+     * Get last record
+     */
+    async last(options) {
+        const { documents } = await this.list({
+            orderBy: ["id", "desc"],
+            ...options,
+            limit: 1,
+        });
+        return documents[0];
+    }
+    /**
+     * Get last cached record
+     */
+    async lastCached(options) {
+        const { documents } = await this.listCached({
+            orderBy: ["id", "desc"],
+            ...options,
+            limit: 1,
+        });
+        return documents[0];
+    }
+    /**
+     * Get last active record
+     */
+    async lastActive(options) {
+        const { documents } = await this.list({
+            orderBy: ["id", "desc"],
+            ...this.getIsActiveFilter(),
+            ...options,
+            limit: 1,
+        });
+        return documents[0];
+    }
+    /**
+     * Get last active cached record
+     */
+    async lastActiveCached(options) {
+        const { documents } = await this.listCached({
+            orderBy: ["id", "desc"],
+            ...this.getIsActiveFilter(),
+            ...options,
+            limit: 1,
+        });
+        return documents[0];
+    }
+    /**
+     * Make filter
+     */
+    async filter(_query, _options) {
+        //
+    }
+    /**
+     * {@inheritdoc}
+     */
+    orderBy(_options) {
+        //
+    }
+    /**
+     * Find By id
+     */
+    async find(id) {
+        if (this.model && id instanceof this.model)
+            return id;
+        return await this.findBy("id", Number(id));
+    }
+    /**
+     * Find active document
+     */
+    async findActive(id) {
+        if (this.model && id instanceof this.model)
+            return id;
+        return await this.findBy("id", Number(id));
+    }
+    /**
+     * Find by the given column
+     */
+    async findBy(column, value) {
+        return this.first({
+            perform(query) {
+                query.where(column, value);
+            },
+        });
+    }
+    /**
+     * Find by the given column and make sure it is active
+     */
+    async findByActive(column, value) {
+        const isActiveFilter = this.getIsActiveFilter();
+        return this.first({
+            perform(query) {
+                query.where({
+                    ...isActiveFilter,
+                    [column]: value,
+                });
+            },
+        });
+    }
+    /**
+     * Find by the given column and cache it
+     * @alias getCached
+     */
+    async findCached(id) {
+        if (id instanceof cascade.Model)
+            return id;
+        return await this.getCached(id);
+    }
+    /**
+     * Find by the given column and cache it
+     * @alias getCachedBy
+     */
+    async findByCached(column, value) {
+        return await this.getCachedBy(column, value);
+    }
+}exports.RepositoryListManager=RepositoryListManager;//# sourceMappingURL=repository-list-manager.js.map