@warlock.js/core 4.0.6 → 4.0.15

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

@@ -1,812 +0,0 @@
-'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');// @TODO: Split the listing class into multiple classes for each type of listing, like general listing, active listing, cached listing, etc.
-// @TODO: Use Proxy to handle the methods and properties of the class
-// @TODO: Add container object to add the methods inside it instead of making multiple checks inside the proxy, so it can be more performant.
-// @TODO: Make sure to fully handle Cursor pagination
-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(() => {
-            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, await model.serialize());
-    }
-    /**
-     * 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.serialize());
-        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;
-        this.cache(cacheKey, await model.serialize());
-        return model;
-    }
-    /**
-     * Clear model cache
-     */
-    async clearModelCache(model) {
-        const { request } = injectRequestContext.useRequestStore();
-        const localeCode = request?.locale ? `locale.${request.locale}.` : "";
-        const cacheKey = this.cacheKey(`data.${localeCode}id.${model.id}`);
-        await this.cacheDriver.remove(cacheKey);
-    }
-    /**
-     * 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.serialize());
-            // 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.serialize());
-            // 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;
-    }
-    /**
-     * Check if document exists for the given filter
-     */
-    async exists(filter = {}) {
-        return !!(await this.first(filter));
-    }
-    /**
-     * Check if the document exists and is active
-     */
-    async existsActive(filter = {}) {
-        return !!(await this.firstActive(filter));
-    }
-    /**
-     * Check if the document exists and is active and cached
-     */
-    async existsActiveCached(filter = {}) {
-        return !!(await this.firstActiveCached(filter));
-    }
-    /**
-     * Check if document exists and is cached
-     */
-    async existsCached(filter = {}) {
-        return !!(await this.firstCached(filter));
-    }
-    /**
-     * Check if document exists for the given id
-     */
-    async idExists(id) {
-        return !!(await this.get(Number(id)));
-    }
-    /**
-     * Check if document exists for the given id and is active
-     */
-    async idExistsActive(id) {
-        return !!(await this.getActive(Number(id)));
-    }
-    /**
-     * Check if document exists for the given id and is active and cached
-     */
-    async idExistsActiveCached(id) {
-        return !!(await this.getActiveCached(Number(id)));
-    }
-    /**
-     * Check if document exists for the given id and is cached
-     */
-    async idExistsCached(id) {
-        return !!(await this.getCached(Number(id)));
-    }
-    /**
-     * 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 Active cached content for the given id
-     */
-    async findActiveCached(id) {
-        return await this.getActiveCached(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