@contentrain/query 3.0.0 → 3.1.0

package/dist/index.d.mts

@@ -1,8 +1,9 @@
 interface ContentrainConfig {
     contentDir: string;
+    defaultLocale?: string;
     models: {
         [modelId: string]: {
-            localized?: boolean;
+            localized: boolean;
             defaultLocale?: string;
             locales?: string[];
         };
@@ -76,19 +77,7 @@ interface FieldValidations {
         };
     };
 }
-interface AssetMetadata {
-    path: string;
-    size: number;
-    type: string;
-    createdAt: string;
-    updatedAt: string;
-}
 type ContentrainLocales = string;
-interface QueryConfig<TFields extends BaseContentrainType, TLocales extends ContentrainLocales, TRelations extends Record<string, BaseContentrainType>> {
-    fields: TFields;
-    locales: TLocales;
-    relations: TRelations;
-}
 
 interface ContentLoaderOptions {
     contentDir: string;
@@ -109,11 +98,26 @@ interface ContentFile<T extends BaseContentrainType = BaseContentrainType> {
     locale?: string;
     data: T[];
 }
+interface AssetMetadata {
+    path: string;
+    mimetype: string;
+    size: number;
+    alt: string;
+    meta: {
+        user: {
+            name: string;
+            email: string;
+            avatar: string;
+        };
+        createdAt: string;
+    };
+}
 interface LoaderResult<T extends BaseContentrainType = BaseContentrainType> {
     model: ModelConfig;
     content: {
         [locale: string]: T[];
     };
+    assets?: AssetMetadata[];
 }
 interface RelationConfig {
     model: string;
@@ -132,12 +136,19 @@ interface CacheEntry<T> {
     size: number;
     createdAt: number;
 }
+interface MemoryCacheOptions {
+    maxSize?: number;
+    defaultTTL?: number;
+}
 
-type Operator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith';
-interface Filter {
+type StringOperator = 'eq' | 'ne' | 'contains' | 'startsWith' | 'endsWith';
+type NumericOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
+type ArrayOperator = 'in' | 'nin';
+type Operator = StringOperator | NumericOperator | ArrayOperator;
+interface Filter<T = any> {
     field: string;
     operator: Operator;
-    value: any;
+    value: T extends Array<infer U> ? (ArrayOperator extends 'in' | 'nin' ? U[] : U) : T;
 }
 interface Sort {
     field: string;
@@ -167,6 +178,11 @@ interface QueryResult<T> {
         hasMore: boolean;
     };
 }
+interface QueryConfig<TFields extends BaseContentrainType, TLocales extends ContentrainLocales = 'en' | 'tr', TRelations extends Record<string, BaseContentrainType> = Record<string, never>> {
+    fields: TFields;
+    locales: TLocales;
+    relations: TRelations;
+}
 
 declare class ContentLoader {
     private options;
@@ -182,6 +198,7 @@ declare class ContentLoader {
     private loadModelConfig;
     private loadContentFile;
     private loadRelations;
+    private getModelLocales;
     load<T extends BaseContentrainType>(model: string): Promise<LoaderResult<T>>;
     resolveRelation<T extends BaseContentrainType, R extends BaseContentrainType>(model: string, relationField: keyof T, data: T[], locale?: string): Promise<R[]>;
 }
@@ -193,6 +210,7 @@ declare class QueryExecutor {
     private applySorting;
     private applyPagination;
     private resolveIncludes;
+    private applyStringOperation;
     execute<T extends BaseContentrainType>({ model, data, filters, includes, sorting, pagination, options, }: {
         model: string;
         data: T[];
@@ -228,13 +246,10 @@ declare class ContentrainQueryBuilder<TFields extends BaseContentrainType, TLoca
     bypassCache(): this;
     toJSON(): {
         model: string;
-        filters: Filter[];
+        filters: Filter<any>[];
         includes: Include;
         sorting: Sort[];
-        pagination: {
-            limit?: number;
-            offset?: number;
-        };
+        pagination: Pagination;
         options: QueryOptions;
     };
     get(): Promise<QueryResult<TFields>>;
@@ -242,10 +257,6 @@ declare class ContentrainQueryBuilder<TFields extends BaseContentrainType, TLoca
     count(): Promise<number>;
 }
 
-interface MemoryCacheOptions {
-    maxSize?: number;
-    defaultTTL?: number;
-}
 declare class MemoryCache {
     private cache;
     private options;
@@ -267,6 +278,9 @@ declare class ContentrainSDK {
     constructor(options: ContentLoaderOptions);
     query<T extends QueryConfig<BaseContentrainType, string, Record<string, BaseContentrainType>>>(model: string): ContentrainQueryBuilder<T['fields'], T['locales'], T['relations']>;
     load<T extends BaseContentrainType>(model: string): Promise<LoaderResult<T>>;
+    clearCache(): Promise<void>;
+    refreshCache(model: string): Promise<void>;
+    getCacheStats(): CacheStats;
 }
 
-export { type AssetMetadata, type BaseContentrainType, type CacheEntry, type CacheStats, type ContentFile, ContentLoader, type ContentLoaderOptions, type ContentrainComponentId, type ContentrainConfig, type ContentrainFieldType, type ContentrainLocales, ContentrainQueryBuilder, ContentrainSDK, type ContentrainStatus, type FieldMetadata, type FieldOptions, type FieldValidations, type Filter, type Include, type LoaderResult, MemoryCache, type MemoryCacheOptions, type ModelConfig, type ModelMetadata, type Operator, type Pagination, type QueryConfig, QueryExecutor, type QueryOptions, type QueryResult, type RelationConfig, type Sort };
+export { type ArrayOperator, type AssetMetadata, type BaseContentrainType, type CacheEntry, type CacheStats, type ContentFile, ContentLoader, type ContentLoaderOptions, type ContentrainComponentId, type ContentrainConfig, type ContentrainFieldType, type ContentrainLocales, ContentrainQueryBuilder, ContentrainSDK, type ContentrainStatus, type FieldMetadata, type FieldOptions, type FieldValidations, type Filter, type Include, type LoaderResult, MemoryCache, type MemoryCacheOptions, type ModelConfig, type ModelMetadata, type NumericOperator, type Operator, type Pagination, type QueryConfig, QueryExecutor, type QueryOptions, type QueryResult, type RelationConfig, type Sort, type StringOperator };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 interface ContentrainConfig {
     contentDir: string;
+    defaultLocale?: string;
     models: {
         [modelId: string]: {
-            localized?: boolean;
+            localized: boolean;
             defaultLocale?: string;
             locales?: string[];
         };
@@ -76,19 +77,7 @@ interface FieldValidations {
         };
     };
 }
-interface AssetMetadata {
-    path: string;
-    size: number;
-    type: string;
-    createdAt: string;
-    updatedAt: string;
-}
 type ContentrainLocales = string;
-interface QueryConfig<TFields extends BaseContentrainType, TLocales extends ContentrainLocales, TRelations extends Record<string, BaseContentrainType>> {
-    fields: TFields;
-    locales: TLocales;
-    relations: TRelations;
-}
 
 interface ContentLoaderOptions {
     contentDir: string;
@@ -109,11 +98,26 @@ interface ContentFile<T extends BaseContentrainType = BaseContentrainType> {
     locale?: string;
     data: T[];
 }
+interface AssetMetadata {
+    path: string;
+    mimetype: string;
+    size: number;
+    alt: string;
+    meta: {
+        user: {
+            name: string;
+            email: string;
+            avatar: string;
+        };
+        createdAt: string;
+    };
+}
 interface LoaderResult<T extends BaseContentrainType = BaseContentrainType> {
     model: ModelConfig;
     content: {
         [locale: string]: T[];
     };
+    assets?: AssetMetadata[];
 }
 interface RelationConfig {
     model: string;
@@ -132,12 +136,19 @@ interface CacheEntry<T> {
     size: number;
     createdAt: number;
 }
+interface MemoryCacheOptions {
+    maxSize?: number;
+    defaultTTL?: number;
+}
 
-type Operator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith';
-interface Filter {
+type StringOperator = 'eq' | 'ne' | 'contains' | 'startsWith' | 'endsWith';
+type NumericOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
+type ArrayOperator = 'in' | 'nin';
+type Operator = StringOperator | NumericOperator | ArrayOperator;
+interface Filter<T = any> {
     field: string;
     operator: Operator;
-    value: any;
+    value: T extends Array<infer U> ? (ArrayOperator extends 'in' | 'nin' ? U[] : U) : T;
 }
 interface Sort {
     field: string;
@@ -167,6 +178,11 @@ interface QueryResult<T> {
         hasMore: boolean;
     };
 }
+interface QueryConfig<TFields extends BaseContentrainType, TLocales extends ContentrainLocales = 'en' | 'tr', TRelations extends Record<string, BaseContentrainType> = Record<string, never>> {
+    fields: TFields;
+    locales: TLocales;
+    relations: TRelations;
+}
 
 declare class ContentLoader {
     private options;
@@ -182,6 +198,7 @@ declare class ContentLoader {
     private loadModelConfig;
     private loadContentFile;
     private loadRelations;
+    private getModelLocales;
     load<T extends BaseContentrainType>(model: string): Promise<LoaderResult<T>>;
     resolveRelation<T extends BaseContentrainType, R extends BaseContentrainType>(model: string, relationField: keyof T, data: T[], locale?: string): Promise<R[]>;
 }
@@ -193,6 +210,7 @@ declare class QueryExecutor {
     private applySorting;
     private applyPagination;
     private resolveIncludes;
+    private applyStringOperation;
     execute<T extends BaseContentrainType>({ model, data, filters, includes, sorting, pagination, options, }: {
         model: string;
         data: T[];
@@ -228,13 +246,10 @@ declare class ContentrainQueryBuilder<TFields extends BaseContentrainType, TLoca
     bypassCache(): this;
     toJSON(): {
         model: string;
-        filters: Filter[];
+        filters: Filter<any>[];
         includes: Include;
         sorting: Sort[];
-        pagination: {
-            limit?: number;
-            offset?: number;
-        };
+        pagination: Pagination;
         options: QueryOptions;
     };
     get(): Promise<QueryResult<TFields>>;
@@ -242,10 +257,6 @@ declare class ContentrainQueryBuilder<TFields extends BaseContentrainType, TLoca
     count(): Promise<number>;
 }
 
-interface MemoryCacheOptions {
-    maxSize?: number;
-    defaultTTL?: number;
-}
 declare class MemoryCache {
     private cache;
     private options;
@@ -267,6 +278,9 @@ declare class ContentrainSDK {
     constructor(options: ContentLoaderOptions);
     query<T extends QueryConfig<BaseContentrainType, string, Record<string, BaseContentrainType>>>(model: string): ContentrainQueryBuilder<T['fields'], T['locales'], T['relations']>;
     load<T extends BaseContentrainType>(model: string): Promise<LoaderResult<T>>;
+    clearCache(): Promise<void>;
+    refreshCache(model: string): Promise<void>;
+    getCacheStats(): CacheStats;
 }
 
-export { type AssetMetadata, type BaseContentrainType, type CacheEntry, type CacheStats, type ContentFile, ContentLoader, type ContentLoaderOptions, type ContentrainComponentId, type ContentrainConfig, type ContentrainFieldType, type ContentrainLocales, ContentrainQueryBuilder, ContentrainSDK, type ContentrainStatus, type FieldMetadata, type FieldOptions, type FieldValidations, type Filter, type Include, type LoaderResult, MemoryCache, type MemoryCacheOptions, type ModelConfig, type ModelMetadata, type Operator, type Pagination, type QueryConfig, QueryExecutor, type QueryOptions, type QueryResult, type RelationConfig, type Sort };
+export { type ArrayOperator, type AssetMetadata, type BaseContentrainType, type CacheEntry, type CacheStats, type ContentFile, ContentLoader, type ContentLoaderOptions, type ContentrainComponentId, type ContentrainConfig, type ContentrainFieldType, type ContentrainLocales, ContentrainQueryBuilder, ContentrainSDK, type ContentrainStatus, type FieldMetadata, type FieldOptions, type FieldValidations, type Filter, type Include, type LoaderResult, MemoryCache, type MemoryCacheOptions, type ModelConfig, type ModelMetadata, type NumericOperator, type Operator, type Pagination, type QueryConfig, QueryExecutor, type QueryOptions, type QueryResult, type RelationConfig, type Sort, type StringOperator };

package/dist/index.js

@@ -174,14 +174,6 @@ var _ContentLoader = class _ContentLoader {
       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
@@ -190,12 +182,22 @@ var _ContentLoader = class _ContentLoader {
       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) {
+            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,7 +205,7 @@ var _ContentLoader = class _ContentLoader {
         const data = JSON.parse(content);
         return {
           model,
-          locale,
+          locale: modelConfig.metadata.localization ? locale : void 0,
           data
         };
       } catch {
@@ -243,8 +245,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 +281,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);
@@ -297,14 +338,16 @@ 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;
-        });
+        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}`);
@@ -390,7 +433,20 @@ var _ContentrainQueryBuilder = class _ContentrainQueryBuilder {
   }
   async get() {
     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;
+    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;
+    }
     return this.executor.execute({
       model: this.model,
       data,
@@ -420,50 +476,67 @@ var _QueryExecutor = class _QueryExecutor {
   }
   applyFilters(data, filters) {
     return data.filter((item) => {
-      return filters.every((filter) => {
-        const value = item[filter.field];
+      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)) {
+          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}`);
+          }
         }
-        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 (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;
       });
     });
   }
   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;
     });
@@ -506,6 +579,24 @@ var _QueryExecutor = class _QueryExecutor {
     }
     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,
@@ -556,6 +647,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;