@contentrain/query 2.0.0 → 3.0.0

package/dist/index.d.ts

@@ -1,28 +1,272 @@
-import { IContentrainCore } from '@contentrain/core';
-import { ContentrainBaseModel, FilterCondition, SortDirection, WithRelation } from '@contentrain/types';
+interface ContentrainConfig {
+    contentDir: 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;
+        };
+    };
+}
+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;
+    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 LoaderResult<T extends BaseContentrainType = BaseContentrainType> {
+    model: ModelConfig;
+    content: {
+        [locale: string]: T[];
+    };
+}
+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;
+}
+
+type Operator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith';
+interface Filter {
+    field: string;
+    operator: Operator;
+    value: any;
+}
+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;
+    };
+}
+
+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;
+    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;
+    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[];
+        includes: Include;
+        sorting: Sort[];
+        pagination: {
+            limit?: number;
+            offset?: number;
+        };
+        options: QueryOptions;
+    };
+    get(): Promise<QueryResult<TFields>>;
+    first(): Promise<TFields | null>;
+    count(): Promise<number>;
+}
+
+interface MemoryCacheOptions {
+    maxSize?: number;
+    defaultTTL?: 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>>;
+}
+
+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 };