@contentrain/query 2.0.1 → 3.1.0

package/dist/index.d.ts

@@ -1,28 +1,286 @@
-import { IContentrainCore } from '@contentrain/core';
-import { ContentrainBaseModel, FilterCondition, SortDirection, WithRelation } from '@contentrain/types';
+interface ContentrainConfig {
+    contentDir: string;
+    defaultLocale?: string;
+    models: {
+        [modelId: string]: {
+            localized: boolean;
+            defaultLocale?: string;
+            locales?: string[];
+        };
+    };
+}
 
-declare class ContentrainQuery<T extends ContentrainBaseModel> {
-    private core;
-    private collection;
-    private filters;
-    private sorts;
+interface BaseContentrainType {
+    ID: string;
+    createdAt: string;
+    updatedAt: string;
+    status: 'draft' | 'changed' | 'publish';
+    scheduled: boolean;
+    _relations?: {
+        [key: string]: BaseContentrainType | BaseContentrainType[];
+    };
+}
+type ContentrainStatus = 'draft' | 'changed' | 'publish';
+interface ModelMetadata {
+    name: string;
+    modelId: string;
+    localization: boolean;
+    type: 'JSON';
+    createdBy: string;
+    isServerless: boolean;
+}
+interface FieldMetadata {
+    name: string;
+    fieldId: string;
+    modelId: string;
+    componentId: ContentrainComponentId;
+    fieldType: ContentrainFieldType;
+    options: FieldOptions;
+    validations: FieldValidations;
+    system?: boolean;
+    defaultField?: boolean;
+}
+type ContentrainFieldType = 'string' | 'number' | 'boolean' | 'array' | 'date' | 'media' | 'relation';
+type ContentrainComponentId = 'single-line-text' | 'multi-line-text' | 'email' | 'url' | 'slug' | 'color' | 'json' | 'md-editor' | 'rich-text-editor' | 'integer' | 'decimal' | 'rating' | 'percent' | 'phone-number' | 'checkbox' | 'switch' | 'date' | 'date-time' | 'media' | 'one-to-one' | 'one-to-many';
+interface FieldOptions {
+    'title-field'?: {
+        value: boolean;
+    };
+    'default-value'?: {
+        value: boolean;
+        form: {
+            [key: string]: {
+                value: any;
+            };
+        };
+    };
+    'reference'?: {
+        value: boolean;
+        form: {
+            reference: {
+                value: string;
+            };
+        };
+    };
+}
+interface FieldValidations {
+    'required-field'?: {
+        value: boolean;
+    };
+    'unique-field'?: {
+        value: boolean;
+    };
+    'input-range-field'?: {
+        value: {
+            min: number;
+            max: number;
+        };
+    };
+}
+type ContentrainLocales = string;
+
+interface ContentLoaderOptions {
+    contentDir: string;
+    defaultLocale?: string;
+    cache?: boolean;
+    ttl?: number;
+    maxCacheSize?: number;
+    modelTTL?: {
+        [model: string]: number;
+    };
+}
+interface ModelConfig {
+    metadata: ModelMetadata;
+    fields: FieldMetadata[];
+}
+interface ContentFile<T extends BaseContentrainType = BaseContentrainType> {
+    model: string;
+    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;
+    type: 'one-to-one' | 'one-to-many';
+    foreignKey: string;
+}
+interface CacheStats {
+    hits: number;
+    misses: number;
+    size: number;
+    lastCleanup: number;
+}
+interface CacheEntry<T> {
+    data: T;
+    expireAt: number;
+    size: number;
+    createdAt: number;
+}
+interface MemoryCacheOptions {
+    maxSize?: number;
+    defaultTTL?: number;
+}
+
+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: T extends Array<infer U> ? (ArrayOperator extends 'in' | 'nin' ? U[] : U) : T;
+}
+interface Sort {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+interface Pagination {
+    limit?: number;
+    offset?: number;
+}
+interface Include {
+    [relation: string]: {
+        fields?: string[];
+        include?: Include;
+    };
+}
+interface QueryOptions {
+    locale?: string;
+    cache?: boolean;
+    ttl?: number;
+}
+interface QueryResult<T> {
+    data: T[];
+    total: number;
+    pagination?: {
+        limit: number;
+        offset: number;
+        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;
+    private modelConfigs;
     private relations;
-    private limitCount?;
-    private skipCount?;
-    constructor(core: IContentrainCore | undefined, collection: string);
-    where(field: keyof T, operator: FilterCondition<T>['operator'], value: T[keyof T]): this;
-    sort(field: keyof T, direction?: SortDirection): this;
-    take(limit: number): this;
-    offset(skip: number): this;
-    with(relation: keyof T): this;
-    private getModelMetadata;
-    private getRelatedData;
-    private evaluateFilter;
-    private evaluateSort;
-    get(): Promise<T[]>;
-    getWithRelations<K extends keyof T>(): Promise<WithRelation<T, K>[]>;
-    first(): Promise<T | null>;
-    firstWithRelations<K extends keyof T>(): Promise<WithRelation<T, K> | null>;
-}
-
-export { ContentrainQuery };
+    private cache;
+    constructor(options: ContentLoaderOptions);
+    private getCacheKey;
+    private getModelTTL;
+    clearCache(): Promise<void>;
+    refreshCache(model: string): Promise<void>;
+    getCacheStats(): CacheStats;
+    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[]>;
+}
+
+declare class QueryExecutor {
+    private loader;
+    constructor(loader: ContentLoader);
+    private applyFilters;
+    private applySorting;
+    private applyPagination;
+    private resolveIncludes;
+    private applyStringOperation;
+    execute<T extends BaseContentrainType>({ model, data, filters, includes, sorting, pagination, options, }: {
+        model: string;
+        data: T[];
+        filters?: Filter[];
+        includes?: Include;
+        sorting?: Sort[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+        };
+        options?: QueryOptions;
+    }): Promise<QueryResult<T>>;
+}
+
+declare class ContentrainQueryBuilder<TFields extends BaseContentrainType, TLocales extends ContentrainLocales = 'en' | 'tr', TRelations extends Record<string, BaseContentrainType> = Record<string, never>> {
+    private model;
+    private filters;
+    private includes;
+    private sorting;
+    private pagination;
+    private options;
+    private executor;
+    private loader;
+    constructor(model: string, executor: QueryExecutor, loader: ContentLoader);
+    where<K extends keyof TFields, O extends Operator>(field: K, operator: O, value: O extends 'in' ? TFields[K][] : TFields[K]): this;
+    include<K extends keyof TRelations>(relation: K | K[]): this;
+    orderBy<K extends keyof TFields>(field: K, direction?: 'asc' | 'desc'): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    locale(code: TLocales): this;
+    cache(ttl?: number): this;
+    noCache(): this;
+    bypassCache(): this;
+    toJSON(): {
+        model: string;
+        filters: Filter<any>[];
+        includes: Include;
+        sorting: Sort[];
+        pagination: Pagination;
+        options: QueryOptions;
+    };
+    get(): Promise<QueryResult<TFields>>;
+    first(): Promise<TFields | null>;
+    count(): Promise<number>;
+}
+
+declare class MemoryCache {
+    private cache;
+    private options;
+    private stats;
+    constructor(options?: MemoryCacheOptions);
+    private calculateSize;
+    set<T>(key: string, data: T, ttl?: number): Promise<void>;
+    private findOldestKey;
+    get<T>(key: string): Promise<T | null>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    private cleanupCache;
+    getStats(): CacheStats;
+}
+
+declare class ContentrainSDK {
+    private loader;
+    private executor;
+    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 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 };