@contentrain/query 3.0.0 → 3.2.0

package/dist/index.js

@@ -3,9 +3,25 @@
 var promises = require('fs/promises');
 var path = require('path');
 var tinyLru = require('tiny-lru');
+var process = require('process');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var isDevelopment = process.env.NODE_ENV === "development";
+var logger = {
+  debug: /* @__PURE__ */ __name((...args) => {
+    if (isDevelopment) {
+      console.log(...args);
+    }
+  }, "debug"),
+  error: /* @__PURE__ */ __name((...args) => {
+    if (isDevelopment) {
+      console.error(...args);
+    }
+  }, "error")
+};
+
+// src/cache/memory.ts
 var _MemoryCache = class _MemoryCache {
   constructor(options = {}) {
     this.stats = {
@@ -29,6 +45,10 @@ var _MemoryCache = class _MemoryCache {
     return new TextEncoder().encode(str).length;
   }
   async set(key, data, ttl) {
+    logger.debug("Saving data to cache:", {
+      key,
+      ttl
+    });
     await this.cleanupCache();
     const size = this.calculateSize(data);
     const now = Date.now();
@@ -51,6 +71,10 @@ var _MemoryCache = class _MemoryCache {
     }
     this.cache.set(key, entry);
     this.stats.size += size;
+    logger.debug("Data saved to cache:", {
+      key,
+      expiry: expireAt ? new Date(expireAt).toISOString() : "no expiry"
+    });
   }
   findOldestKey() {
     let oldestKey = null;
@@ -65,8 +89,10 @@ var _MemoryCache = class _MemoryCache {
     return oldestKey;
   }
   async get(key) {
+    logger.debug("Getting data from cache:", { key });
     const entry = this.cache.get(key);
     if (!entry) {
+      logger.debug("Data not found in cache:", { key });
       this.stats.misses++;
       return null;
     }
@@ -75,17 +101,24 @@ var _MemoryCache = class _MemoryCache {
       this.stats.misses++;
       return null;
     }
+    logger.debug("Data retrieved from cache:", {
+      key,
+      expiry: entry.expireAt ? new Date(entry.expireAt).toISOString() : "no expiry"
+    });
     this.stats.hits++;
     return entry.data;
   }
   async delete(key) {
+    logger.debug("Deleting data from cache:", { key });
     const entry = this.cache.get(key);
     if (entry) {
       this.stats.size -= entry.size;
       this.cache.delete(key);
     }
+    logger.debug("Data deleted from cache:", { key });
   }
   async clear() {
+    logger.debug("Clearing cache");
     this.cache.clear();
     this.stats = {
       hits: 0,
@@ -93,6 +126,7 @@ var _MemoryCache = class _MemoryCache {
       size: 0,
       lastCleanup: Date.now()
     };
+    logger.debug("Cache cleared");
   }
   async cleanupCache() {
     const now = Date.now();
@@ -135,7 +169,7 @@ var _ContentLoader = class _ContentLoader {
       defaultLocale: "en",
       cache: true,
       ttl: 60 * 1e3,
-      // 1 dakika
+      // 1 minute
       maxCacheSize: 100,
       // 100 MB
       ...options
@@ -169,33 +203,46 @@ var _ContentLoader = class _ContentLoader {
       const allMetadata = JSON.parse(metadataContent);
       const modelMetadata = allMetadata.find((m) => m.modelId === model);
       if (!modelMetadata) {
+        logger.error("Model metadata not found:", {
+          model,
+          metadataPath
+        });
         throw new Error(`Model metadata not found for ${model}`);
       }
       const modelPath = path.join(this.options.contentDir, "models", `${model}.json`);
       const modelContent = await promises.readFile(modelPath, "utf-8");
       const modelFields = JSON.parse(modelContent);
-      if (!Array.isArray(modelFields)) {
-        throw new TypeError(`Invalid field configuration for model ${model}: Expected an array of fields`);
-      }
-      modelFields.forEach((field, index) => {
-        if (!field.fieldId || !field.fieldType || !field.componentId) {
-          throw new Error(`Invalid field at index ${index} for model ${model}: Missing required properties`);
-        }
-      });
       return {
         metadata: modelMetadata,
         fields: modelFields
       };
     } catch (error) {
+      logger.error("Failed to load model config:", {
+        model,
+        error: error?.message || "Unknown error"
+      });
       throw new Error(`Failed to load model config for ${model}: ${error?.message || "Unknown error"}`);
     }
   }
-  async loadContentFile(model, locale) {
+  async loadContentFile(model, locale = "default") {
     try {
+      const modelConfig = await this.loadModelConfig(model);
       let contentPath;
-      if (locale) {
+      if (modelConfig.metadata.localization) {
+        if (!locale || locale === "default") {
+          if (!this.options.defaultLocale) {
+            logger.error("Default locale is required for localized model:", {
+              model
+            });
+            throw new Error(`Default locale is required for localized model "${model}"`);
+          }
+          locale = this.options.defaultLocale;
+        }
         contentPath = path.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 = path.join(this.options.contentDir, model, `${model}.json`);
       }
       const content = await promises.readFile(contentPath, "utf-8");
@@ -203,14 +250,23 @@ var _ContentLoader = class _ContentLoader {
         const data = JSON.parse(content);
         return {
           model,
-          locale,
+          locale: modelConfig.metadata.localization ? locale : void 0,
           data
         };
       } catch {
+        logger.error("Failed to load content:", {
+          model,
+          locale,
+          contentPath
+        });
         throw new Error(`Failed to load content: Invalid JSON format in ${contentPath}`);
       }
     } catch (error) {
       if (error.message.includes("Invalid JSON format")) {
+        logger.error("Failed to load content:", {
+          model,
+          locale
+        });
         throw error;
       }
       throw new Error(
@@ -243,8 +299,31 @@ var _ContentLoader = class _ContentLoader {
       throw new Error(`Failed to load relations for ${model}: ${error?.message || "Unknown error"}`);
     }
   }
+  async getModelLocales(model, modelConfig) {
+    try {
+      if (!modelConfig.metadata.localization) {
+        return ["default"];
+      }
+      const modelDir = path.join(this.options.contentDir, model);
+      const files = await promises.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];
+    }
+  }
   async load(model) {
-    const cacheKey = this.getCacheKey(model);
+    const cacheKey = `${model}`;
     if (this.options.cache) {
       const cached = await this.cache.get(cacheKey);
       if (cached)
@@ -256,18 +335,34 @@ var _ContentLoader = class _ContentLoader {
     this.relations.set(model, relations);
     const content = {};
     if (modelConfig.metadata.localization) {
-      const locales = ["en", "tr"];
+      const locales = await this.getModelLocales(model, modelConfig);
       for (const locale of locales) {
-        const file = await this.loadContentFile(model, locale);
-        content[locale] = file.data;
+        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;
     }
+    let assets = [];
+    try {
+      const assetsPath = path.join(this.options.contentDir, "assets.json");
+      const assetsContent = await promises.readFile(assetsPath, "utf-8");
+      assets = JSON.parse(assetsContent);
+    } catch (error) {
+      console.warn("Assets file not found or cannot be read:", error);
+    }
     const result = {
       model: modelConfig,
-      content
+      content,
+      assets
     };
     if (this.options.cache) {
       const ttl = this.getModelTTL(model);
@@ -277,19 +372,65 @@ var _ContentLoader = class _ContentLoader {
   }
   async resolveRelation(model, relationField, data, locale) {
     try {
+      logger.debug("Debug - Starting relation resolution:", {
+        model,
+        relationField,
+        dataLength: data.length,
+        locale
+      });
       const relations = this.relations.get(model);
+      logger.debug("Debug - Relations:", relations);
       if (!relations)
         throw new Error(`No relations found for model: ${model}`);
       const relation = relations.find((r) => r.foreignKey === relationField);
+      logger.debug("Debug - Found relation:", relation);
       if (!relation)
         throw new Error(`No relation found for field: ${String(relationField)}`);
+      logger.debug("Debug - Related model loading:", relation.model);
       const relatedContent = await this.load(relation.model);
-      const relatedData = locale ? relatedContent.content[locale] : relatedContent.content.en;
+      logger.debug("Debug - \u0130li\u015Fkili model y\xFCklendi:", {
+        model: relation.model,
+        metadata: relatedContent.model.metadata,
+        contentKeys: Object.keys(relatedContent.content)
+      });
+      let relatedData;
+      if (relatedContent.model.metadata.localization) {
+        logger.debug("Debug - Processing localized model");
+        const localizedContent = locale ? relatedContent.content[locale] : relatedContent.content.en;
+        logger.debug("Debug - Localized content:", {
+          locale: locale || "en",
+          contentType: typeof localizedContent,
+          isArray: Array.isArray(localizedContent)
+        });
+        if (!Array.isArray(localizedContent)) {
+          throw new TypeError(`Invalid content format for localized model ${relation.model}`);
+        }
+        relatedData = localizedContent;
+      } else {
+        logger.debug("Debug - Processing non-localized model");
+        const nonLocalizedContent = relatedContent.content.default;
+        logger.debug("Debug - Raw content:", {
+          contentType: typeof nonLocalizedContent,
+          isArray: Array.isArray(nonLocalizedContent),
+          content: nonLocalizedContent
+        });
+        if (!Array.isArray(nonLocalizedContent)) {
+          throw new TypeError(`Invalid content format for non-localized model ${relation.model}`);
+        }
+        relatedData = nonLocalizedContent;
+      }
+      logger.debug("Debug - Related data ready:", {
+        dataLength: relatedData.length,
+        firstItem: relatedData[0]
+      });
       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) => {
+        logger.debug("Debug - Processing one-to-one relation");
+        const itemsWithRelation = data.filter((item) => item[relationField] !== void 0);
+        logger.debug("Debug - Items with relations:", itemsWithRelation.length);
+        return itemsWithRelation.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])}`);
@@ -297,16 +438,22 @@ var _ContentLoader = class _ContentLoader {
           return relatedItem;
         });
       } else {
-        return data.flatMap((item) => {
-          const ids = Array.isArray(item[relationField]) ? item[relationField] : [item[relationField]];
-          const items = ids.map((id) => relatedData.find((r) => r.ID === id)).filter(Boolean);
-          if (items.length !== ids.length) {
-            throw new Error("Failed to resolve relation: Some related items not found");
-          }
-          return items;
-        });
+        logger.debug("Debug - Processing one-to-many relation");
+        const uniqueIds = new Set(
+          data.flatMap(
+            (item) => item[relationField] !== void 0 ? Array.isArray(item[relationField]) ? item[relationField] : [item[relationField]] : []
+          )
+        );
+        logger.debug("Debug - Unique IDs:", Array.from(uniqueIds));
+        const items = Array.from(uniqueIds).map((id) => relatedData.find((r) => r.ID === id)).filter(Boolean);
+        logger.debug("Debug - Matching items:", items.length);
+        if (items.length !== uniqueIds.size) {
+          throw new Error("Failed to resolve relation: Some related items not found");
+        }
+        return items;
       }
     } catch (error) {
+      logger.error("Debug - Error occurred:", error);
       throw new Error(`Failed to resolve relation: ${error.message}`);
     }
   }
@@ -327,6 +474,11 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     this.loader = loader;
   }
   where(field, operator, value) {
+    logger.debug("Adding filter:", {
+      field,
+      operator,
+      value
+    });
     this.filters.push({
       field,
       operator,
@@ -335,6 +487,7 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     return this;
   }
   include(relation) {
+    logger.debug("Adding relation:", relation);
     if (typeof relation === "string") {
       this.includes[relation] = {};
     } else if (Array.isArray(relation)) {
@@ -345,6 +498,10 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     return this;
   }
   orderBy(field, direction = "asc") {
+    logger.debug("Adding sorting:", {
+      field,
+      direction
+    });
     this.sorting.push({
       field,
       direction
@@ -352,28 +509,37 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     return this;
   }
   limit(count) {
+    logger.debug("Adding limit:", count);
     this.pagination.limit = count;
     return this;
   }
   offset(count) {
+    logger.debug("Adding offset:", count);
     this.pagination.offset = count;
     return this;
   }
   locale(code) {
+    logger.debug("Setting locale:", code);
     this.options.locale = code;
     return this;
   }
   cache(ttl) {
+    logger.debug("Setting cache:", {
+      enabled: true,
+      ttl
+    });
     this.options.cache = true;
     if (ttl)
       this.options.ttl = ttl;
     return this;
   }
   noCache() {
+    logger.debug("Disabling cache");
     this.options.cache = false;
     return this;
   }
   bypassCache() {
+    logger.debug("Bypassing cache");
     this.options.cache = false;
     this.options.ttl = 0;
     return this;
@@ -389,8 +555,56 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     };
   }
   async get() {
+    logger.debug("Starting query:", {
+      model: this.model,
+      filterCount: this.filters.length,
+      includeCount: Object.keys(this.includes).length,
+      sortingCount: this.sorting.length,
+      pagination: this.pagination,
+      options: this.options
+    });
     const result = await this.loader.load(this.model);
-    const data = this.options.locale ? result.content[this.options.locale] : result.content.en;
+    const modelConfig = result.model;
+    logger.debug("Model loaded:", {
+      model: this.model,
+      metadata: modelConfig.metadata,
+      contentKeys: Object.keys(result.content)
+    });
+    let data;
+    if (modelConfig.metadata.localization) {
+      const locale = this.options.locale || "en";
+      logger.debug("Selecting content for localized model:", {
+        model: this.model,
+        requestedLocale: locale,
+        availableLocales: Object.keys(result.content)
+      });
+      data = result.content[locale];
+      if (!data) {
+        logger.error("Content not found:", {
+          model: this.model,
+          locale,
+          availableLocales: Object.keys(result.content)
+        });
+        throw new Error(`Content not found for locale: ${locale}`);
+      }
+    } else {
+      logger.debug("Selecting content for non-localized model:", {
+        model: this.model,
+        contentKeys: Object.keys(result.content)
+      });
+      if (!result.content.default) {
+        logger.error("Content not found:", {
+          model: this.model,
+          contentKeys: Object.keys(result.content)
+        });
+        throw new Error(`Content not found for model: ${this.model}`);
+      }
+      data = result.content.default;
+    }
+    logger.debug("Executing query:", {
+      model: this.model,
+      dataLength: data.length
+    });
     return this.executor.execute({
       model: this.model,
       data,
@@ -419,51 +633,80 @@ var _QueryExecutor = class _QueryExecutor {
     this.loader = loader;
   }
   applyFilters(data, filters) {
-    return data.filter((item) => {
-      return filters.every((filter) => {
-        const value = item[filter.field];
+    logger.debug("Starting to apply filters:", {
+      dataLength: data.length,
+      filters
+    });
+    const result = 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(filter.operator)) {
-          throw new Error(`Invalid operator: ${filter.operator}`);
+        if (!validOperators.includes(operator)) {
+          logger.error("Invalid operator:", 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:
+              logger.error("Invalid array operator:", operator);
+              throw new Error(`Invalid array operator: ${operator}`);
+          }
         }
-        switch (filter.operator) {
-          case "eq":
-            return value === filter.value;
-          case "ne":
-            return value !== filter.value;
-          case "gt":
-            return value > filter.value;
-          case "gte":
-            return value >= filter.value;
-          case "lt":
-            return value < filter.value;
-          case "lte":
-            return value <= filter.value;
-          case "in":
-            return Array.isArray(filter.value) && filter.value.includes(value);
-          case "nin":
-            return Array.isArray(filter.value) && !filter.value.includes(value);
-          case "contains":
-            return typeof value === "string" && value.includes(filter.value);
-          case "startsWith":
-            return typeof value === "string" && value.startsWith(filter.value);
-          case "endsWith":
-            return typeof value === "string" && value.endsWith(filter.value);
-          default:
-            return false;
+        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:
+              logger.error("Invalid array operator:", operator);
+              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 false;
       });
     });
+    logger.debug("Filter application completed:", {
+      initialCount: data.length,
+      resultCount: result.length
+    });
+    return result;
   }
   applySorting(data, sorting) {
     return [...data].sort((a, b) => {
-      for (const sort of sorting) {
-        const aValue = a[sort.field];
-        const bValue = b[sort.field];
+      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 direction = sort.direction === "asc" ? 1 : -1;
-        return aValue > bValue ? direction : -direction;
+        const compareResult = aValue < bValue ? -1 : 1;
+        return direction === "asc" ? compareResult : -compareResult;
       }
       return 0;
     });
@@ -474,15 +717,26 @@ var _QueryExecutor = class _QueryExecutor {
     return data.slice(offset, offset + limit);
   }
   async resolveIncludes(model, data, includes, options) {
+    logger.debug("Starting to resolve relations:", {
+      model,
+      dataLength: data.length,
+      includes,
+      options
+    });
     const result = [...data];
     for (const [field, config] of Object.entries(includes)) {
+      logger.debug(`Resolving relation "${field}"`);
       const relations = await this.loader.resolveRelation(
         model,
         field,
         result,
         options.locale
       );
+      logger.debug(`Relation "${field}" resolved:`, {
+        foundRelationsCount: relations.length
+      });
       if (config.include && relations.length) {
+        logger.debug(`Resolving nested relations for "${field}":`, config.include);
         await this.resolveIncludes(
           field,
           relations,
@@ -503,9 +757,28 @@ var _QueryExecutor = class _QueryExecutor {
         }
         item._relations[field] = Array.isArray(value) ? relatedItems : relatedItems[0];
       });
+      logger.debug(`Data added for relation "${field}"`);
     }
     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;
+      }
+    }
+  }
   async execute({
     model,
     data,
@@ -515,17 +788,37 @@ var _QueryExecutor = class _QueryExecutor {
     pagination = {},
     options = {}
   }) {
+    logger.debug("Starting execution:", {
+      model,
+      dataLength: data.length,
+      filterCount: filters.length,
+      includeCount: Object.keys(includes).length,
+      sortingCount: sorting.length,
+      pagination,
+      options
+    });
     let result = [...data];
     if (filters.length) {
+      logger.debug("Applying filters:", filters);
       result = this.applyFilters(result, filters);
+      logger.debug("Remaining items after filtering:", result.length);
     }
     if (Object.keys(includes).length) {
+      logger.debug("Resolving relations:", includes);
       result = await this.resolveIncludes(model, result, includes, options);
+      logger.debug("Items after relation resolution:", result.length);
     }
     if (sorting.length) {
+      logger.debug("Applying sorting:", sorting);
       result = this.applySorting(result, sorting);
     }
     const paginatedData = this.applyPagination(result, pagination.limit, pagination.offset);
+    logger.debug("After pagination:", {
+      totalCount: result.length,
+      pageSize: paginatedData.length,
+      offset: pagination.offset || 0,
+      hasMore: (pagination.offset || 0) + paginatedData.length < result.length
+    });
     return {
       data: paginatedData,
       total: result.length,
@@ -556,6 +849,15 @@ var _ContentrainSDK = class _ContentrainSDK {
   async load(model) {
     return this.loader.load(model);
   }
+  async clearCache() {
+    return this.loader.clearCache();
+  }
+  async refreshCache(model) {
+    return this.loader.refreshCache(model);
+  }
+  getCacheStats() {
+    return this.loader.getCacheStats();
+  }
 };
 __name(_ContentrainSDK, "ContentrainSDK");
 var ContentrainSDK = _ContentrainSDK;
@@ -565,5 +867,6 @@ exports.ContentrainQueryBuilder = ContentrainQueryBuilder;
 exports.ContentrainSDK = ContentrainSDK;
 exports.MemoryCache = MemoryCache;
 exports.QueryExecutor = QueryExecutor;
+exports.logger = logger;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map