@contentrain/query 3.1.0 → 3.2.0

package/dist/index.mjs

@@ -1,9 +1,25 @@
 import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { lru } from 'tiny-lru';
+import { env } from 'node:process';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var isDevelopment = 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 = {
@@ -27,6 +43,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();
@@ -49,6 +69,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;
@@ -63,8 +87,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;
     }
@@ -73,17 +99,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,
@@ -91,6 +124,7 @@ var _MemoryCache = class _MemoryCache {
       size: 0,
       lastCleanup: Date.now()
     };
+    logger.debug("Cache cleared");
   }
   async cleanupCache() {
     const now = Date.now();
@@ -133,7 +167,7 @@ var _ContentLoader = class _ContentLoader {
       defaultLocale: "en",
       cache: true,
       ttl: 60 * 1e3,
-      // 1 dakika
+      // 1 minute
       maxCacheSize: 100,
       // 100 MB
       ...options
@@ -167,6 +201,10 @@ 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 = join(this.options.contentDir, "models", `${model}.json`);
@@ -177,6 +215,10 @@ var _ContentLoader = class _ContentLoader {
         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"}`);
     }
   }
@@ -187,6 +229,9 @@ var _ContentLoader = class _ContentLoader {
       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;
@@ -207,10 +252,19 @@ var _ContentLoader = class _ContentLoader {
           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(
@@ -295,7 +349,7 @@ var _ContentLoader = class _ContentLoader {
       const file = await this.loadContentFile(model);
       content.default = file.data;
     }
-    let assets;
+    let assets = [];
     try {
       const assetsPath = join(this.options.contentDir, "assets.json");
       const assetsContent = await readFile(assetsPath, "utf-8");
@@ -316,19 +370,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])}`);
@@ -336,18 +436,22 @@ var _ContentLoader = class _ContentLoader {
           return relatedItem;
         });
       } else {
+        logger.debug("Debug - Processing one-to-many relation");
         const uniqueIds = new Set(
           data.flatMap(
-            (item) => Array.isArray(item[relationField]) ? item[relationField] : [item[relationField]]
+            (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}`);
     }
   }
@@ -368,6 +472,11 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     this.loader = loader;
   }
   where(field, operator, value) {
+    logger.debug("Adding filter:", {
+      field,
+      operator,
+      value
+    });
     this.filters.push({
       field,
       operator,
@@ -376,6 +485,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)) {
@@ -386,6 +496,10 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
     return this;
   }
   orderBy(field, direction = "asc") {
+    logger.debug("Adding sorting:", {
+      field,
+      direction
+    });
     this.sorting.push({
       field,
       direction
@@ -393,28 +507,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;
@@ -430,21 +553,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 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,
@@ -473,11 +631,16 @@ var _QueryExecutor = class _QueryExecutor {
     this.loader = loader;
   }
   applyFilters(data, filters) {
-    return data.filter((item) => {
+    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(operator)) {
+          logger.error("Invalid operator:", operator);
           throw new Error(`Invalid operator: ${operator}`);
         }
         if (typeof itemValue === "string" && typeof value === "string") {
@@ -490,6 +653,7 @@ var _QueryExecutor = class _QueryExecutor {
             case "nin":
               return !value.includes(itemValue);
             default:
+              logger.error("Invalid array operator:", operator);
               throw new Error(`Invalid array operator: ${operator}`);
           }
         }
@@ -500,6 +664,7 @@ var _QueryExecutor = class _QueryExecutor {
             case "nin":
               return !value.some((v) => itemValue.includes(v));
             default:
+              logger.error("Invalid array operator:", operator);
               throw new Error(`Invalid array operator: ${operator}`);
           }
         }
@@ -522,6 +687,11 @@ var _QueryExecutor = class _QueryExecutor {
         return false;
       });
     });
+    logger.debug("Filter application completed:", {
+      initialCount: data.length,
+      resultCount: result.length
+    });
+    return result;
   }
   applySorting(data, sorting) {
     return [...data].sort((a, b) => {
@@ -545,15 +715,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,
@@ -574,6 +755,7 @@ var _QueryExecutor = class _QueryExecutor {
         }
         item._relations[field] = Array.isArray(value) ? relatedItems : relatedItems[0];
       });
+      logger.debug(`Data added for relation "${field}"`);
     }
     return result;
   }
@@ -604,17 +786,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,
@@ -658,6 +860,6 @@ var _ContentrainSDK = class _ContentrainSDK {
 __name(_ContentrainSDK, "ContentrainSDK");
 var ContentrainSDK = _ContentrainSDK;
 
-export { ContentLoader, ContentrainQueryBuilder, ContentrainSDK, MemoryCache, QueryExecutor };
+export { ContentLoader, ContentrainQueryBuilder, ContentrainSDK, MemoryCache, QueryExecutor, logger };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map