@contentrain/query 3.2.0 → 5.0.0

package/dist/index.mjs

@@ -1,865 +1,349 @@
-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 = {
-      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);
-  }
-  calculateSize(data) {
-    const str = JSON.stringify(data);
-    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();
-    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;
-    logger.debug("Data saved to cache:", {
-      key,
-      expiry: expireAt ? new Date(expireAt).toISOString() : "no expiry"
-    });
-  }
-  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;
-  }
-  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;
-    }
-    if (Date.now() >= entry.expireAt) {
-      await this.delete(key);
-      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,
-      misses: 0,
-      size: 0,
-      lastCleanup: Date.now()
-    };
-    logger.debug("Cache cleared");
-  }
-  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;
-      }
-    }
-    for (const key of expiredKeys) {
-      await this.delete(key);
-    }
-    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;
-    }
-    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 minute
-      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) {
-        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`);
-      const modelContent = await readFile(modelPath, "utf-8");
-      const modelFields = JSON.parse(modelContent);
-      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 = "default") {
-    try {
-      const modelConfig = await this.loadModelConfig(model);
-      let contentPath;
-      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 = 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 {
-        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(
-        `Failed to load content file for ${model}${locale ? ` (${locale})` : ""}: ${error?.message || "Unknown error"}`
-      );
-    }
-  }
-  async loadRelations(model) {
-    try {
-      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"}`);
-    }
-  }
-  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];
-    }
-  }
-  async load(model) {
-    const cacheKey = `${model}`;
-    if (this.options.cache) {
-      const cached = await this.cache.get(cacheKey);
-      if (cached)
-        return cached;
-    }
-    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;
-    }
-    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);
-    }
-    const result = {
-      model: modelConfig,
-      content,
-      assets
-    };
-    if (this.options.cache) {
-      const ttl = this.getModelTTL(model);
-      await this.cache.set(cacheKey, result, ttl);
-    }
-    return result;
-  }
-  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);
-      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") {
-        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])}`);
-          }
-          return relatedItem;
-        });
-      } else {
-        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}`);
-    }
-  }
+//#region src/runtime/query.ts
+var QueryBuilder = class {
+	_data;
+	_locale = null;
+	_filters = [];
+	_sortField = null;
+	_sortOrder = "asc";
+	_limit = null;
+	_offset = 0;
+	_includes = [];
+	_relationMeta;
+	_resolver;
+	_defaultLocale;
+	constructor(data, relationMeta, resolver, defaultLocale) {
+		this._data = data;
+		this._relationMeta = relationMeta ?? {};
+		this._resolver = resolver ?? null;
+		this._defaultLocale = defaultLocale ?? null;
+	}
+	locale(lang) {
+		this._locale = lang;
+		return this;
+	}
+	where(field, value) {
+		this._filters.push((item) => {
+			const v = item[field];
+			if (Array.isArray(v)) return v.includes(value);
+			return v === value;
+		});
+		return this;
+	}
+	sort(field, order = "asc") {
+		this._sortField = field;
+		this._sortOrder = order;
+		return this;
+	}
+	limit(n) {
+		this._limit = n;
+		return this;
+	}
+	offset(n) {
+		this._offset = n;
+		return this;
+	}
+	include(...fields) {
+		this._includes.push(...fields);
+		return this;
+	}
+	all() {
+		let items = this._resolveData();
+		for (const filter of this._filters) items = items.filter(filter);
+		if (this._sortField) {
+			const field = this._sortField;
+			const dir = this._sortOrder === "asc" ? 1 : -1;
+			items.sort((a, b) => {
+				const va = a[field];
+				const vb = b[field];
+				if (va == null && vb == null) return 0;
+				if (va == null) return dir;
+				if (vb == null) return -dir;
+				if (va < vb) return -dir;
+				if (va > vb) return dir;
+				return 0;
+			});
+		}
+		if (this._offset > 0 || this._limit !== null) {
+			const end = this._limit !== null ? this._offset + this._limit : void 0;
+			items = items.slice(this._offset, end);
+		}
+		if (this._includes.length > 0 && this._resolver) items = items.map((item) => this._resolveIncludes(item));
+		return items;
+	}
+	first() {
+		return this.all()[0];
+	}
+	_resolveData() {
+		if (this._locale) return [...this._data.get(this._locale) ?? []];
+		if (this._defaultLocale) {
+			const defaultData = this._data.get(this._defaultLocale);
+			if (defaultData) return [...defaultData];
+		}
+		const firstKey = this._data.keys().next().value;
+		if (firstKey !== void 0) return [...this._data.get(firstKey) ?? []];
+		return [];
+	}
+	_resolveIncludes(item) {
+		const resolved = { ...item };
+		const src = item;
+		const dst = resolved;
+		for (const field of this._includes) {
+			const meta = this._relationMeta[field];
+			if (!meta) continue;
+			const targets = Array.isArray(meta.target) ? meta.target : [meta.target];
+			if (meta.multi) {
+				const ids = src[field];
+				if (Array.isArray(ids)) dst[field] = ids.map((id) => {
+					if (typeof id === "string") return this._resolveId(targets, id) ?? id;
+					if (typeof id === "object" && id !== null && "model" in id && "ref" in id) {
+						const polyObj = id;
+						return this._resolveId([polyObj.model], polyObj.ref) ?? id;
+					}
+					return id;
+				});
+			} else {
+				const id = src[field];
+				if (typeof id === "string") dst[field] = this._resolveId(targets, id) ?? id;
+				else if (typeof id === "object" && id !== null && "model" in id && "ref" in id) {
+					const polyObj = id;
+					dst[field] = this._resolveId([polyObj.model], polyObj.ref) ?? id;
+				}
+			}
+		}
+		return resolved;
+	}
+	_resolveId(targets, id) {
+		for (const target of targets) {
+			const result = this._resolver(target, id, this._locale);
+			if (result) return result;
+		}
+	}
 };
-__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) {
-    logger.debug("Adding filter:", {
-      field,
-      operator,
-      value
-    });
-    this.filters.push({
-      field,
-      operator,
-      value
-    });
-    return this;
-  }
-  include(relation) {
-    logger.debug("Adding relation:", relation);
-    if (typeof relation === "string") {
-      this.includes[relation] = {};
-    } else if (Array.isArray(relation)) {
-      relation.forEach((r) => {
-        this.includes[r] = {};
-      });
-    }
-    return this;
-  }
-  orderBy(field, direction = "asc") {
-    logger.debug("Adding sorting:", {
-      field,
-      direction
-    });
-    this.sorting.push({
-      field,
-      direction
-    });
-    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;
-  }
-  toJSON() {
-    return {
-      model: this.model,
-      filters: this.filters,
-      includes: this.includes,
-      sorting: this.sorting,
-      pagination: this.pagination,
-      options: this.options
-    };
-  }
-  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,
-      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;
-  }
+//#endregion
+//#region src/runtime/singleton.ts
+var SingletonAccessor = class {
+	_data;
+	_locale = null;
+	_defaultLocale;
+	_includes = [];
+	_relationMeta = {};
+	_resolveEntry;
+	constructor(data, defaultLocale, relationMeta, resolveEntry) {
+		this._data = data;
+		this._defaultLocale = defaultLocale ?? null;
+		if (relationMeta) this._relationMeta = relationMeta;
+		this._resolveEntry = resolveEntry;
+	}
+	locale(lang) {
+		this._locale = lang;
+		return this;
+	}
+	include(...fields) {
+		this._includes.push(...fields);
+		return this;
+	}
+	get() {
+		if (this._locale) {
+			const d = this._data.get(this._locale);
+			if (!d) throw new Error(`No data for locale "${this._locale}"`);
+			if (this._includes.length > 0) return this._resolveIncludes(d, this._locale);
+			return d;
+		}
+		const locale = this._defaultLocale ?? void 0;
+		let data;
+		if (locale) data = this._data.get(locale);
+		if (!data) {
+			const firstKey = this._data.keys().next().value;
+			if (firstKey !== void 0) data = this._data.get(firstKey);
+		}
+		if (!data) throw new Error("No data available");
+		if (this._includes.length > 0) return this._resolveIncludes(data, locale ?? "en");
+		return data;
+	}
+	_resolveIncludes(item, locale) {
+		if (!this._resolveEntry || this._includes.length === 0) return item;
+		const resolved = { ...item };
+		const src = item;
+		const dst = resolved;
+		for (const field of this._includes) {
+			const meta = this._relationMeta[field];
+			if (!meta) continue;
+			const targets = Array.isArray(meta.target) ? meta.target : [meta.target];
+			if (meta.multi) {
+				const ids = src[field];
+				if (Array.isArray(ids)) dst[field] = ids.map((id) => {
+					if (typeof id === "string") return this._resolveId(targets, id, locale) ?? id;
+					if (typeof id === "object" && id !== null && "model" in id && "ref" in id) {
+						const polyObj = id;
+						return this._resolveId([polyObj.model], polyObj.ref, locale) ?? id;
+					}
+					return id;
+				});
+			} else {
+				const id = src[field];
+				if (typeof id === "string") dst[field] = this._resolveId(targets, id, locale) ?? id;
+				else if (typeof id === "object" && id !== null && "model" in id && "ref" in id) {
+					const polyObj = id;
+					dst[field] = this._resolveId([polyObj.model], polyObj.ref, locale) ?? id;
+				}
+			}
+		}
+		return resolved;
+	}
+	_resolveId(targets, id, locale) {
+		if (!this._resolveEntry) return void 0;
+		for (const model of targets) {
+			const result = this._resolveEntry(model, id, locale);
+			if (result) return result;
+		}
+	}
 };
-__name(_ContentrainQueryBuilder, "ContentrainQueryBuilder");
-var ContentrainQueryBuilder = _ContentrainQueryBuilder;
-
-// src/query/executor.ts
-var _QueryExecutor = class _QueryExecutor {
-  constructor(loader) {
-    this.loader = loader;
-  }
-  applyFilters(data, filters) {
-    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") {
-          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}`);
-          }
-        }
-        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 { 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) {
-    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,
-          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];
-      });
-      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,
-    filters = [],
-    includes = {},
-    sorting = [],
-    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,
-      pagination: pagination.limit ? {
-        limit: pagination.limit,
-        offset: pagination.offset || 0,
-        hasMore: (pagination.offset || 0) + paginatedData.length < result.length
-      } : undefined
-    };
-  }
+//#endregion
+//#region src/runtime/dictionary.ts
+var DictionaryAccessor = class {
+	_data;
+	_locale = null;
+	_defaultLocale;
+	constructor(data, defaultLocale) {
+		this._data = data;
+		this._defaultLocale = defaultLocale ?? null;
+	}
+	locale(lang) {
+		this._locale = lang;
+		return this;
+	}
+	get(key, params) {
+		const dict = this._resolveData();
+		if (key === void 0) return dict;
+		const value = dict[key];
+		if (value === void 0) return void 0;
+		if (params) return interpolate(value, params);
+		return value;
+	}
+	_resolveData() {
+		if (this._locale) return this._data.get(this._locale) ?? {};
+		if (this._defaultLocale) {
+			const d = this._data.get(this._defaultLocale);
+			if (d) return d;
+		}
+		const firstKey = this._data.keys().next().value;
+		if (firstKey !== void 0) return this._data.get(firstKey) ?? {};
+		return {};
+	}
 };
-__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 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();
-  }
+function interpolate(template, params) {
+	return template.replace(/\{(\w+)\}/g, (match, key) => {
+		const val = params[key];
+		return val !== void 0 ? String(val) : match;
+	});
+}
+//#endregion
+//#region src/runtime/document.ts
+var DocumentQuery = class {
+	_data;
+	_locale = null;
+	_filters = [];
+	_includes = [];
+	_relationMeta;
+	_resolver;
+	_defaultLocale;
+	constructor(data, relationMeta, resolver, defaultLocale) {
+		this._data = data;
+		this._relationMeta = relationMeta ?? {};
+		this._resolver = resolver ?? null;
+		this._defaultLocale = defaultLocale ?? null;
+	}
+	locale(lang) {
+		this._locale = lang;
+		return this;
+	}
+	where(field, value) {
+		this._filters.push((item) => item[field] === value);
+		return this;
+	}
+	include(...fields) {
+		this._includes.push(...fields);
+		return this;
+	}
+	bySlug(slug) {
+		const item = this._resolveData().find((i) => i["slug"] === slug);
+		if (item && this._includes.length > 0 && this._resolver) return this._resolveIncludes(item);
+		return item;
+	}
+	all() {
+		let items = this._resolveData();
+		for (const filter of this._filters) items = items.filter(filter);
+		if (this._includes.length > 0 && this._resolver) items = items.map((item) => this._resolveIncludes(item));
+		return items;
+	}
+	first() {
+		return this.all()[0];
+	}
+	_resolveData() {
+		if (this._locale) return [...this._data.get(this._locale) ?? []];
+		if (this._defaultLocale) {
+			const defaultData = this._data.get(this._defaultLocale);
+			if (defaultData) return [...defaultData];
+		}
+		const firstKey = this._data.keys().next().value;
+		if (firstKey !== void 0) return [...this._data.get(firstKey) ?? []];
+		return [];
+	}
+	_resolveIncludes(item) {
+		const resolved = { ...item };
+		const src = item;
+		const dst = resolved;
+		for (const field of this._includes) {
+			const meta = this._relationMeta[field];
+			if (!meta) continue;
+			const targets = Array.isArray(meta.target) ? meta.target : [meta.target];
+			if (meta.multi) {
+				const ids = src[field];
+				if (Array.isArray(ids)) dst[field] = ids.map((id) => {
+					if (typeof id === "string") return this._resolveId(targets, id) ?? id;
+					if (typeof id === "object" && id !== null && "model" in id && "ref" in id) {
+						const polyObj = id;
+						return this._resolveId([polyObj.model], polyObj.ref) ?? id;
+					}
+					return id;
+				});
+			} else {
+				const id = src[field];
+				if (typeof id === "string") dst[field] = this._resolveId(targets, id) ?? id;
+				else if (typeof id === "object" && id !== null && "model" in id && "ref" in id) {
+					const polyObj = id;
+					dst[field] = this._resolveId([polyObj.model], polyObj.ref) ?? id;
+				}
+			}
+		}
+		return resolved;
+	}
+	_resolveId(targets, id) {
+		for (const target of targets) {
+			const result = this._resolver(target, id, this._locale);
+			if (result) return result;
+		}
+	}
 };
-__name(_ContentrainSDK, "ContentrainSDK");
-var ContentrainSDK = _ContentrainSDK;
+//#endregion
+//#region src/index.ts
+/**
+* Factory for framework SDK authors.
+* Returns the generated client module loaded from .contentrain/client/.
+*
+* Usage (Nuxt composable):
+* ```ts
+* import { createContentrainClient } from '@contentrain/query'
+* const client = createContentrainClient()
+* const posts = client.query('blog-post').locale('en').all()
+* ```
+*/
+async function createContentrainClient(projectRoot) {
+	const { resolve } = await import("node:path");
+	const { pathToFileURL } = await import("node:url");
+	return await import(pathToFileURL(resolve(projectRoot ?? process.cwd(), ".contentrain", "client", "index.mjs")).href);
+}
+//#endregion
+export { DictionaryAccessor, DocumentQuery, QueryBuilder, SingletonAccessor, createContentrainClient, createContentrainClient as default };
 
-export { ContentLoader, ContentrainQueryBuilder, ContentrainSDK, MemoryCache, QueryExecutor, logger };
-//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map