@contentrain/query 2.0.1 → 3.1.0

package/dist/index.mjs

@@ -1,185 +1,663 @@
-// src/index.ts
-import { ContentrainCore } from "@contentrain/core";
-var ContentrainQuery = class {
-  constructor(core = new ContentrainCore(), collection) {
-    this.core = core;
-    this.collection = collection;
-  }
-  filters = [];
-  sorts = [];
-  relations = [];
-  limitCount;
-  skipCount;
-  where(field, operator, value) {
-    this.filters.push({ field, operator, value });
-    return this;
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { lru } from 'tiny-lru';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var _MemoryCache = class _MemoryCache {
+  constructor(options = {}) {
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      size: 0,
+      lastCleanup: Date.now()
+    };
+    this.options = {
+      maxSize: 100,
+      // 100 MB
+      defaultTTL: 60 * 1e3,
+      // 1 dakika
+      ...options
+    };
+    const maxItems = Math.floor(this.options.maxSize * 1024 * 1024 / 1e3);
+    this.cache = lru(maxItems);
   }
-  sort(field, direction = "asc") {
-    this.sorts.push({ field, direction });
-    return this;
+  calculateSize(data) {
+    const str = JSON.stringify(data);
+    return new TextEncoder().encode(str).length;
   }
-  take(limit) {
-    this.limitCount = limit;
-    return this;
+  async set(key, data, ttl) {
+    await this.cleanupCache();
+    const size = this.calculateSize(data);
+    const now = Date.now();
+    const expireAt = now + (ttl || this.options.defaultTTL);
+    while (size + this.stats.size > this.options.maxSize * 1024 * 1024) {
+      const oldestKey = this.findOldestKey();
+      if (!oldestKey)
+        break;
+      await this.delete(oldestKey);
+    }
+    const entry = {
+      data,
+      expireAt,
+      size,
+      createdAt: now
+    };
+    const oldEntry = this.cache.get(key);
+    if (oldEntry) {
+      this.stats.size -= oldEntry.size;
+    }
+    this.cache.set(key, entry);
+    this.stats.size += size;
   }
-  offset(skip) {
-    this.skipCount = skip;
-    return this;
+  findOldestKey() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const key of this.cache.keys()) {
+      const entry = this.cache.get(key);
+      if (entry.createdAt < oldestTime) {
+        oldestTime = entry.createdAt;
+        oldestKey = key;
+      }
+    }
+    return oldestKey;
   }
-  with(relation) {
-    this.relations.push(relation);
-    return this;
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return null;
+    }
+    if (Date.now() >= entry.expireAt) {
+      await this.delete(key);
+      this.stats.misses++;
+      return null;
+    }
+    this.stats.hits++;
+    return entry.data;
+  }
+  async delete(key) {
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.stats.size -= entry.size;
+      this.cache.delete(key);
+    }
   }
-  async getModelMetadata() {
-    return this.core.getModelMetadata(this.collection);
+  async clear() {
+    this.cache.clear();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      size: 0,
+      lastCleanup: Date.now()
+    };
   }
-  async getRelatedData(item, relation) {
-    const metadata = await this.getModelMetadata();
-    const fields = metadata.fields;
-    const fieldMetadata = fields.find((f) => f.id === relation);
-    if (!fieldMetadata) {
-      throw new Error(`Field ${relation} not found in model ${metadata.modelId}`);
+  async cleanupCache() {
+    const now = Date.now();
+    const expiredKeys = [];
+    let totalSize = 0;
+    for (const key of this.cache.keys()) {
+      const entry = this.cache.get(key);
+      if (entry.expireAt <= now) {
+        expiredKeys.push(key);
+      } else {
+        totalSize += entry.size;
+      }
     }
-    if (!fieldMetadata.relation?.model) {
-      throw new Error(`Field ${relation} is not a relation`);
+    for (const key of expiredKeys) {
+      await this.delete(key);
     }
-    const relatedIds = item[relation];
-    if (!relatedIds) {
-      return null;
+    while (totalSize > this.options.maxSize * 1024 * 1024) {
+      const oldestKey = this.findOldestKey();
+      if (!oldestKey)
+        break;
+      const entry = this.cache.get(oldestKey);
+      await this.delete(oldestKey);
+      totalSize -= entry.size;
     }
-    const relatedMetadata = await this.core.getModelMetadata(fieldMetadata.relation.model);
-    const hasLocalization = relatedMetadata.localization ?? false;
-    const locale = this.core.getLocale();
-    if (Array.isArray(relatedIds)) {
-      const relatedItems = await Promise.all(
-        relatedIds.map(async (id) => {
-          try {
-            const data = await this.core.getContentById(fieldMetadata.relation.model, id);
-            return hasLocalization && locale && typeof data === "object" && locale in data ? data[locale] : data;
-          } catch {
-            return null;
+    this.stats.lastCleanup = now;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+};
+__name(_MemoryCache, "MemoryCache");
+var MemoryCache = _MemoryCache;
+
+// src/loader/content.ts
+var _ContentLoader = class _ContentLoader {
+  constructor(options) {
+    this.modelConfigs = /* @__PURE__ */ new Map();
+    this.relations = /* @__PURE__ */ new Map();
+    this.options = {
+      defaultLocale: "en",
+      cache: true,
+      ttl: 60 * 1e3,
+      // 1 dakika
+      maxCacheSize: 100,
+      // 100 MB
+      ...options
+    };
+    this.cache = new MemoryCache({
+      maxSize: this.options.maxCacheSize,
+      defaultTTL: this.options.ttl
+    });
+  }
+  getCacheKey(model) {
+    return `${model}`;
+  }
+  getModelTTL(model) {
+    return this.options.modelTTL?.[model] || this.options.ttl || 0;
+  }
+  async clearCache() {
+    await this.cache.clear();
+  }
+  async refreshCache(model) {
+    const cacheKey = this.getCacheKey(model);
+    await this.cache.delete(cacheKey);
+    await this.load(model);
+  }
+  getCacheStats() {
+    return this.cache.getStats();
+  }
+  async loadModelConfig(model) {
+    try {
+      const metadataPath = join(this.options.contentDir, "models", "metadata.json");
+      const metadataContent = await readFile(metadataPath, "utf-8");
+      const allMetadata = JSON.parse(metadataContent);
+      const modelMetadata = allMetadata.find((m) => m.modelId === model);
+      if (!modelMetadata) {
+        throw new Error(`Model metadata not found for ${model}`);
+      }
+      const modelPath = join(this.options.contentDir, "models", `${model}.json`);
+      const modelContent = await readFile(modelPath, "utf-8");
+      const modelFields = JSON.parse(modelContent);
+      return {
+        metadata: modelMetadata,
+        fields: modelFields
+      };
+    } catch (error) {
+      throw new Error(`Failed to load model config for ${model}: ${error?.message || "Unknown error"}`);
+    }
+  }
+  async loadContentFile(model, locale = "default") {
+    try {
+      const modelConfig = await this.loadModelConfig(model);
+      let contentPath;
+      if (modelConfig.metadata.localization) {
+        if (!locale || locale === "default") {
+          if (!this.options.defaultLocale) {
+            throw new Error(`Default locale is required for localized model "${model}"`);
           }
-        })
+          locale = this.options.defaultLocale;
+        }
+        contentPath = join(this.options.contentDir, model, `${locale}.json`);
+      } else {
+        if (locale !== "default") {
+          console.warn(`Locale "${locale}" specified for non-localized model "${model}". This parameter will be ignored.`);
+        }
+        contentPath = join(this.options.contentDir, model, `${model}.json`);
+      }
+      const content = await readFile(contentPath, "utf-8");
+      try {
+        const data = JSON.parse(content);
+        return {
+          model,
+          locale: modelConfig.metadata.localization ? locale : void 0,
+          data
+        };
+      } catch {
+        throw new Error(`Failed to load content: Invalid JSON format in ${contentPath}`);
+      }
+    } catch (error) {
+      if (error.message.includes("Invalid JSON format")) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to load content file for ${model}${locale ? ` (${locale})` : ""}: ${error?.message || "Unknown error"}`
       );
-      return relatedItems.filter((item2) => item2 !== null);
     }
+  }
+  async loadRelations(model) {
     try {
-      const data = await this.core.getContentById(fieldMetadata.relation.model, relatedIds);
-      return hasLocalization && locale && typeof data === "object" && locale in data ? data[locale] : data;
-    } catch {
-      return null;
+      const modelConfig = this.modelConfigs.get(model);
+      if (!modelConfig) {
+        throw new Error(`Model config not found for ${model}`);
+      }
+      const relationFields = modelConfig.fields.filter((field) => {
+        return field.fieldType === "relation";
+      });
+      return relationFields.map((field) => {
+        const options = field.options;
+        const reference = options?.reference?.form?.reference?.value;
+        if (!reference) {
+          throw new Error(`Reference not found for relation field: ${field.name}`);
+        }
+        return {
+          model: reference,
+          type: field.componentId === "one-to-one" ? "one-to-one" : "one-to-many",
+          foreignKey: field.fieldId
+        };
+      });
+    } catch (error) {
+      throw new Error(`Failed to load relations for ${model}: ${error?.message || "Unknown error"}`);
     }
   }
-  evaluateFilter(item, filter) {
-    const { field, operator, value } = filter;
-    const itemValue = item[field];
-    switch (operator) {
-      case "eq":
-        return itemValue === value;
-      case "neq":
-        return itemValue !== value;
-      case "gt":
-        return typeof itemValue === "number" && typeof value === "number" && itemValue > value;
-      case "gte":
-        return typeof itemValue === "number" && typeof value === "number" && itemValue >= value;
-      case "lt":
-        return typeof itemValue === "number" && typeof value === "number" && itemValue < value;
-      case "lte":
-        return typeof itemValue === "number" && typeof value === "number" && itemValue <= value;
-      case "contains":
-        return typeof itemValue === "string" && typeof value === "string" && itemValue.includes(value);
-      case "startsWith":
-        return typeof itemValue === "string" && typeof value === "string" && itemValue.startsWith(value);
-      case "endsWith":
-        return typeof itemValue === "string" && typeof value === "string" && itemValue.endsWith(value);
-      case "in":
-        return Array.isArray(value) && value.includes(itemValue);
-      case "nin":
-        return Array.isArray(value) && !value.includes(itemValue);
-      case "exists":
-        return itemValue !== void 0 && itemValue !== null;
-      case "notExists":
-        return itemValue === void 0 || itemValue === null;
-      default:
-        return false;
+  async getModelLocales(model, modelConfig) {
+    try {
+      if (!modelConfig.metadata.localization) {
+        return ["default"];
+      }
+      const modelDir = join(this.options.contentDir, model);
+      const files = await readdir(modelDir);
+      const locales = files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", "")).filter((locale) => locale !== model);
+      if (locales.length === 0) {
+        if (!this.options.defaultLocale) {
+          throw new Error(`No locale files found for localized model "${model}" and no default locale specified`);
+        }
+        return [this.options.defaultLocale];
+      }
+      return locales;
+    } catch (error) {
+      if (!this.options.defaultLocale) {
+        throw new Error(`Failed to read locales for model ${model} and no default locale specified: ${error?.message}`);
+      }
+      console.warn(`Failed to read locales for model ${model}: ${error?.message}`);
+      return [this.options.defaultLocale];
     }
   }
-  evaluateSort(a, b, sort) {
-    const { field, direction } = sort;
-    const aValue = a[field];
-    const bValue = b[field];
-    if (aValue === bValue) {
-      return 0;
+  async load(model) {
+    const cacheKey = `${model}`;
+    if (this.options.cache) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached)
+        return cached;
     }
-    if (aValue === void 0 || aValue === null) {
-      return direction === "asc" ? -1 : 1;
+    const modelConfig = await this.loadModelConfig(model);
+    this.modelConfigs.set(model, modelConfig);
+    const relations = await this.loadRelations(model);
+    this.relations.set(model, relations);
+    const content = {};
+    if (modelConfig.metadata.localization) {
+      const locales = await this.getModelLocales(model, modelConfig);
+      for (const locale of locales) {
+        try {
+          const file = await this.loadContentFile(model, locale);
+          content[locale] = file.data;
+        } catch (error) {
+          console.warn(`Failed to load content for locale ${locale}: ${error?.message}`);
+          if (locale === this.options.defaultLocale) {
+            throw error;
+          }
+        }
+      }
+    } else {
+      const file = await this.loadContentFile(model);
+      content.default = file.data;
     }
-    if (bValue === void 0 || bValue === null) {
-      return direction === "asc" ? 1 : -1;
+    let assets;
+    try {
+      const assetsPath = join(this.options.contentDir, "assets.json");
+      const assetsContent = await readFile(assetsPath, "utf-8");
+      assets = JSON.parse(assetsContent);
+    } catch (error) {
+      console.warn("Assets file not found or cannot be read:", error);
     }
-    if (typeof aValue === "string" && typeof bValue === "string") {
-      return direction === "asc" ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
+    const result = {
+      model: modelConfig,
+      content,
+      assets
+    };
+    if (this.options.cache) {
+      const ttl = this.getModelTTL(model);
+      await this.cache.set(cacheKey, result, ttl);
     }
-    if (typeof aValue === "number" && typeof bValue === "number") {
-      return direction === "asc" ? aValue - bValue : bValue - aValue;
+    return result;
+  }
+  async resolveRelation(model, relationField, data, locale) {
+    try {
+      const relations = this.relations.get(model);
+      if (!relations)
+        throw new Error(`No relations found for model: ${model}`);
+      const relation = relations.find((r) => r.foreignKey === relationField);
+      if (!relation)
+        throw new Error(`No relation found for field: ${String(relationField)}`);
+      const relatedContent = await this.load(relation.model);
+      const relatedData = locale ? relatedContent.content[locale] : relatedContent.content.en;
+      if (!relatedData) {
+        throw new Error(`Failed to resolve relation: No data found for model ${relation.model}`);
+      }
+      if (relation.type === "one-to-one") {
+        return data.map((item) => {
+          const relatedItem = relatedData.find((r) => r.ID === item[relationField]);
+          if (!relatedItem) {
+            throw new Error(`Failed to resolve relation: No matching item found for ID ${String(item[relationField])}`);
+          }
+          return relatedItem;
+        });
+      } else {
+        const uniqueIds = new Set(
+          data.flatMap(
+            (item) => Array.isArray(item[relationField]) ? item[relationField] : [item[relationField]]
+          )
+        );
+        const items = Array.from(uniqueIds).map((id) => relatedData.find((r) => r.ID === id)).filter(Boolean);
+        if (items.length !== uniqueIds.size) {
+          throw new Error("Failed to resolve relation: Some related items not found");
+        }
+        return items;
+      }
+    } catch (error) {
+      throw new Error(`Failed to resolve relation: ${error.message}`);
+    }
+  }
+};
+__name(_ContentLoader, "ContentLoader");
+var ContentLoader = _ContentLoader;
+
+// src/query/builder.ts
+var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
+  constructor(model, executor, loader) {
+    this.filters = [];
+    this.includes = {};
+    this.sorting = [];
+    this.pagination = {};
+    this.options = {};
+    this.model = model;
+    this.executor = executor;
+    this.loader = loader;
+  }
+  where(field, operator, value) {
+    this.filters.push({
+      field,
+      operator,
+      value
+    });
+    return this;
+  }
+  include(relation) {
+    if (typeof relation === "string") {
+      this.includes[relation] = {};
+    } else if (Array.isArray(relation)) {
+      relation.forEach((r) => {
+        this.includes[r] = {};
+      });
     }
-    return 0;
+    return this;
+  }
+  orderBy(field, direction = "asc") {
+    this.sorting.push({
+      field,
+      direction
+    });
+    return this;
+  }
+  limit(count) {
+    this.pagination.limit = count;
+    return this;
+  }
+  offset(count) {
+    this.pagination.offset = count;
+    return this;
+  }
+  locale(code) {
+    this.options.locale = code;
+    return this;
+  }
+  cache(ttl) {
+    this.options.cache = true;
+    if (ttl)
+      this.options.ttl = ttl;
+    return this;
+  }
+  noCache() {
+    this.options.cache = false;
+    return this;
+  }
+  bypassCache() {
+    this.options.cache = false;
+    this.options.ttl = 0;
+    return this;
+  }
+  toJSON() {
+    return {
+      model: this.model,
+      filters: this.filters,
+      includes: this.includes,
+      sorting: this.sorting,
+      pagination: this.pagination,
+      options: this.options
+    };
   }
   async get() {
-    const metadata = await this.getModelMetadata();
-    const hasLocalization = metadata.localization ?? false;
-    const locale = this.core.getLocale();
-    const items = await this.core.getContent(this.collection);
-    let result = items.map((item) => hasLocalization && locale && typeof item === "object" && locale in item ? item[locale] : item);
-    if (this.filters.length > 0) {
-      result = result.filter(
-        (item) => this.filters.every((filter) => this.evaluateFilter(item, filter))
-      );
+    const result = await this.loader.load(this.model);
+    const modelConfig = result.model;
+    let data;
+    if (modelConfig.metadata.localization) {
+      const locale = this.options.locale || "en";
+      data = result.content[locale];
+      if (!data) {
+        throw new Error(`Content not found for locale: ${locale}`);
+      }
+    } else {
+      if (!result.content.default) {
+        throw new Error(`Content not found for model: ${this.model}`);
+      }
+      data = result.content.default;
     }
-    if (this.sorts.length > 0) {
-      result = result.sort((a, b) => {
-        for (const sort of this.sorts) {
-          const comparison = this.evaluateSort(a, b, sort);
-          if (comparison !== 0) {
-            return comparison;
+    return this.executor.execute({
+      model: this.model,
+      data,
+      filters: this.filters,
+      includes: this.includes,
+      sorting: this.sorting,
+      pagination: this.pagination,
+      options: this.options
+    });
+  }
+  async first() {
+    const result = await this.limit(1).get();
+    return result.data[0] || null;
+  }
+  async count() {
+    const result = await this.get();
+    return result.total;
+  }
+};
+__name(_ContentrainQueryBuilder, "ContentrainQueryBuilder");
+var ContentrainQueryBuilder = _ContentrainQueryBuilder;
+
+// src/query/executor.ts
+var _QueryExecutor = class _QueryExecutor {
+  constructor(loader) {
+    this.loader = loader;
+  }
+  applyFilters(data, filters) {
+    return data.filter((item) => {
+      return filters.every(({ field, operator, value }) => {
+        const itemValue = item[field];
+        const validOperators = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "startsWith", "endsWith"];
+        if (!validOperators.includes(operator)) {
+          throw new Error(`Invalid operator: ${operator}`);
+        }
+        if (typeof itemValue === "string" && typeof value === "string") {
+          return this.applyStringOperation(itemValue, operator, value);
+        }
+        if (Array.isArray(value)) {
+          switch (operator) {
+            case "in":
+              return value.includes(itemValue);
+            case "nin":
+              return !value.includes(itemValue);
+            default:
+              throw new Error(`Invalid array operator: ${operator}`);
+          }
+        }
+        if (Array.isArray(itemValue)) {
+          switch (operator) {
+            case "in":
+              return value.some((v) => itemValue.includes(v));
+            case "nin":
+              return !value.some((v) => itemValue.includes(v));
+            default:
+              throw new Error(`Invalid array operator: ${operator}`);
+          }
+        }
+        if (typeof itemValue === "number" && typeof value === "number") {
+          switch (operator) {
+            case "eq":
+              return itemValue === value;
+            case "ne":
+              return itemValue !== value;
+            case "gt":
+              return itemValue > value;
+            case "gte":
+              return itemValue >= value;
+            case "lt":
+              return itemValue < value;
+            case "lte":
+              return itemValue <= value;
           }
         }
-        return 0;
+        return false;
       });
+    });
+  }
+  applySorting(data, sorting) {
+    return [...data].sort((a, b) => {
+      for (const { field, direction } of sorting) {
+        if (!(field in a)) {
+          throw new Error(`Invalid sort field: ${field}`);
+        }
+        const aValue = a[field];
+        const bValue = b[field];
+        if (aValue === bValue)
+          continue;
+        const compareResult = aValue < bValue ? -1 : 1;
+        return direction === "asc" ? compareResult : -compareResult;
+      }
+      return 0;
+    });
+  }
+  applyPagination(data, limit, offset = 0) {
+    if (!limit)
+      return data.slice(offset);
+    return data.slice(offset, offset + limit);
+  }
+  async resolveIncludes(model, data, includes, options) {
+    const result = [...data];
+    for (const [field, config] of Object.entries(includes)) {
+      const relations = await this.loader.resolveRelation(
+        model,
+        field,
+        result,
+        options.locale
+      );
+      if (config.include && relations.length) {
+        await this.resolveIncludes(
+          field,
+          relations,
+          config.include,
+          options
+        );
+      }
+      result.forEach((item) => {
+        const value = item[field];
+        const relatedItems = relations.filter((r) => {
+          if (Array.isArray(value)) {
+            return value.includes(r.ID);
+          }
+          return r.ID === value;
+        });
+        if (!item._relations) {
+          item._relations = {};
+        }
+        item._relations[field] = Array.isArray(value) ? relatedItems : relatedItems[0];
+      });
+    }
+    return result;
+  }
+  applyStringOperation(value, operator, searchValue) {
+    switch (operator) {
+      case "eq":
+        return value === searchValue;
+      case "ne":
+        return value !== searchValue;
+      case "contains":
+        return value.toLowerCase().includes(searchValue.toLowerCase());
+      case "startsWith":
+        return value.toLowerCase().startsWith(searchValue.toLowerCase());
+      case "endsWith":
+        return value.toLowerCase().endsWith(searchValue.toLowerCase());
+      default: {
+        const _exhaustiveCheck = operator;
+        return _exhaustiveCheck;
+      }
     }
-    if (this.skipCount !== void 0) {
-      result = result.slice(this.skipCount);
+  }
+  async execute({
+    model,
+    data,
+    filters = [],
+    includes = {},
+    sorting = [],
+    pagination = {},
+    options = {}
+  }) {
+    let result = [...data];
+    if (filters.length) {
+      result = this.applyFilters(result, filters);
     }
-    if (this.limitCount !== void 0) {
-      result = result.slice(0, this.limitCount);
+    if (Object.keys(includes).length) {
+      result = await this.resolveIncludes(model, result, includes, options);
     }
-    return result;
+    if (sorting.length) {
+      result = this.applySorting(result, sorting);
+    }
+    const paginatedData = this.applyPagination(result, pagination.limit, pagination.offset);
+    return {
+      data: paginatedData,
+      total: result.length,
+      pagination: pagination.limit ? {
+        limit: pagination.limit,
+        offset: pagination.offset || 0,
+        hasMore: (pagination.offset || 0) + paginatedData.length < result.length
+      } : undefined
+    };
   }
-  async getWithRelations() {
-    const items = await this.get();
-    return Promise.all(
-      items.map(async (item) => {
-        const result = { ...item };
-        await Promise.all(
-          this.relations.map(async (relation) => {
-            const relatedData = await this.getRelatedData(item, relation);
-            const relationKey = `${relation}-data`;
-            result[relationKey] = relatedData;
-          })
-        );
-        return result;
-      })
+};
+__name(_QueryExecutor, "QueryExecutor");
+var QueryExecutor = _QueryExecutor;
+
+// src/index.ts
+var _ContentrainSDK = class _ContentrainSDK {
+  constructor(options) {
+    this.loader = new ContentLoader(options);
+    this.executor = new QueryExecutor(this.loader);
+  }
+  query(model) {
+    return new ContentrainQueryBuilder(
+      model,
+      this.executor,
+      this.loader
     );
   }
-  async first() {
-    const items = await this.get();
-    return items[0] ?? null;
+  async load(model) {
+    return this.loader.load(model);
   }
-  async firstWithRelations() {
-    const items = await this.getWithRelations();
-    return items[0] ?? null;
+  async clearCache() {
+    return this.loader.clearCache();
+  }
+  async refreshCache(model) {
+    return this.loader.refreshCache(model);
+  }
+  getCacheStats() {
+    return this.loader.getCacheStats();
   }
 };
-export {
-  ContentrainQuery
-};
+__name(_ContentrainSDK, "ContentrainSDK");
+var ContentrainSDK = _ContentrainSDK;
+
+export { ContentLoader, ContentrainQueryBuilder, ContentrainSDK, MemoryCache, QueryExecutor };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map