@contentrain/query 1.0.0

package/README.md

@@ -0,0 +1,134 @@
+# @contentrain/query
+
+Query builder for Contentrain SDK.
+
+## Installation
+
+```bash
+npm install @contentrain/query @contentrain/core
+```
+
+## Usage
+
+```typescript
+import { ContentrainCore } from '@contentrain/core'
+import { ContentrainQuery } from '@contentrain/query'
+
+// Initialize core and query
+const core = new ContentrainCore()
+const query = new ContentrainQuery(core)
+
+// Basic query
+const posts = await query
+  .from('posts')
+  .where('status', 'publish')
+  .get()
+
+// Complex query
+const featuredPosts = await query
+  .from('posts')
+  .where('status', 'publish')
+  .where('featured', true)
+  .orderBy('createdAt', 'desc')
+  .limit(5)
+  .get()
+
+// Query with relations
+const postsWithAuthor = await query
+  .from('posts')
+  .with('author')
+  .where('status', 'publish')
+  .get()
+
+// Query with multiple conditions
+const searchPosts = await query
+  .from('posts')
+  .where([
+    ['status', 'publish'],
+    ['category', 'technology'],
+    ['title', 'startsWith', 'How to']
+  ])
+  .get()
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+constructor(core: ContentrainCore)
+```
+
+Creates a new instance of ContentrainQuery.
+
+### Methods
+
+#### from
+```typescript
+from(collection: string): ContentrainQuery
+```
+
+Specifies the collection to query.
+
+#### where
+```typescript
+where(field: string, value: any): ContentrainQuery
+where(field: string, operator: FilterOperator, value: any): ContentrainQuery
+where(conditions: [string, any][] | [string, FilterOperator, any][]): ContentrainQuery
+```
+
+Adds where conditions to the query.
+
+#### orderBy
+```typescript
+orderBy(field: string, direction: 'asc' | 'desc' = 'asc'): ContentrainQuery
+```
+
+Orders the results by a field.
+
+#### limit
+```typescript
+limit(count: number): ContentrainQuery
+```
+
+Limits the number of results.
+
+#### offset
+```typescript
+offset(count: number): ContentrainQuery
+```
+
+Skips the specified number of results.
+
+#### with
+```typescript
+with(...relations: string[]): ContentrainQuery
+```
+
+Includes related content in the results.
+
+#### get
+```typescript
+get<T>(): Promise<T[]>
+```
+
+Executes the query and returns the results.
+
+### Filter Operators
+
+- `equals` (default)
+- `notEquals`
+- `contains`
+- `notContains`
+- `startsWith`
+- `endsWith`
+- `exists`
+- `notExists`
+- `gt` (greater than)
+- `gte` (greater than or equal)
+- `lt` (less than)
+- `lte` (less than or equal)
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { IContentrainCore } from '@contentrain/core';
+import { ContentrainBaseModel, FilterCondition, SortDirection, WithRelation } from '@contentrain/types';
+
+declare class ContentrainQuery<T extends ContentrainBaseModel> {
+    private core;
+    private collection;
+    private filters;
+    private sorts;
+    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 };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { IContentrainCore } from '@contentrain/core';
+import { ContentrainBaseModel, FilterCondition, SortDirection, WithRelation } from '@contentrain/types';
+
+declare class ContentrainQuery<T extends ContentrainBaseModel> {
+    private core;
+    private collection;
+    private filters;
+    private sorts;
+    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 };

package/dist/index.js

@@ -0,0 +1,210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ContentrainQuery: () => ContentrainQuery
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@contentrain/core");
+var ContentrainQuery = class {
+  constructor(core = new import_core.ContentrainCore(), collection) {
+    this.core = core;
+    this.collection = collection;
+  }
+  filters = [];
+  sorts = [];
+  relations = [];
+  limitCount;
+  skipCount;
+  where(field, operator, value) {
+    this.filters.push({ field, operator, value });
+    return this;
+  }
+  sort(field, direction = "asc") {
+    this.sorts.push({ field, direction });
+    return this;
+  }
+  take(limit) {
+    this.limitCount = limit;
+    return this;
+  }
+  offset(skip) {
+    this.skipCount = skip;
+    return this;
+  }
+  with(relation) {
+    this.relations.push(relation);
+    return this;
+  }
+  async getModelMetadata() {
+    return this.core.getModelMetadata(this.collection);
+  }
+  async getRelatedData(item, relation) {
+    const metadata = await this.getModelMetadata();
+    const fields = metadata.fields;
+    const fieldMetadata = fields.find((f) => f.id === relation);
+    if (!fieldMetadata) {
+      throw new Error(`Field ${relation} not found in model ${metadata.modelId}`);
+    }
+    if (!fieldMetadata.relation?.model) {
+      throw new Error(`Field ${relation} is not a relation`);
+    }
+    const relatedIds = item[relation];
+    if (!relatedIds) {
+      return null;
+    }
+    const relatedMetadata = await this.core.getModelMetadata(fieldMetadata.relation.model);
+    const hasLocalization = relatedMetadata.localization ?? false;
+    const locale = this.core.getLocale();
+    if (Array.isArray(relatedIds)) {
+      const relatedItems = await Promise.all(
+        relatedIds.map(async (id) => {
+          try {
+            const data = await this.core.getContentById(fieldMetadata.relation.model, id);
+            return hasLocalization && locale && typeof data === "object" && locale in data ? data[locale] : data;
+          } catch {
+            return null;
+          }
+        })
+      );
+      return relatedItems.filter((item2) => item2 !== null);
+    }
+    try {
+      const data = await this.core.getContentById(fieldMetadata.relation.model, relatedIds);
+      return hasLocalization && locale && typeof data === "object" && locale in data ? data[locale] : data;
+    } catch {
+      return null;
+    }
+  }
+  evaluateFilter(item, filter) {
+    const { field, operator, value } = filter;
+    const itemValue = item[field];
+    switch (operator) {
+      case "eq":
+        return itemValue === value;
+      case "neq":
+        return itemValue !== value;
+      case "gt":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue > value;
+      case "gte":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue >= value;
+      case "lt":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue < value;
+      case "lte":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue <= value;
+      case "contains":
+        return typeof itemValue === "string" && typeof value === "string" && itemValue.includes(value);
+      case "startsWith":
+        return typeof itemValue === "string" && typeof value === "string" && itemValue.startsWith(value);
+      case "endsWith":
+        return typeof itemValue === "string" && typeof value === "string" && itemValue.endsWith(value);
+      case "in":
+        return Array.isArray(value) && value.includes(itemValue);
+      case "nin":
+        return Array.isArray(value) && !value.includes(itemValue);
+      case "exists":
+        return itemValue !== void 0 && itemValue !== null;
+      case "notExists":
+        return itemValue === void 0 || itemValue === null;
+      default:
+        return false;
+    }
+  }
+  evaluateSort(a, b, sort) {
+    const { field, direction } = sort;
+    const aValue = a[field];
+    const bValue = b[field];
+    if (aValue === bValue) {
+      return 0;
+    }
+    if (aValue === void 0 || aValue === null) {
+      return direction === "asc" ? -1 : 1;
+    }
+    if (bValue === void 0 || bValue === null) {
+      return direction === "asc" ? 1 : -1;
+    }
+    if (typeof aValue === "string" && typeof bValue === "string") {
+      return direction === "asc" ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
+    }
+    if (typeof aValue === "number" && typeof bValue === "number") {
+      return direction === "asc" ? aValue - bValue : bValue - aValue;
+    }
+    return 0;
+  }
+  async get() {
+    const metadata = await this.getModelMetadata();
+    const hasLocalization = metadata.localization ?? false;
+    const locale = this.core.getLocale();
+    const items = await this.core.getContent(this.collection);
+    let result = items.map((item) => hasLocalization && locale && typeof item === "object" && locale in item ? item[locale] : item);
+    if (this.filters.length > 0) {
+      result = result.filter(
+        (item) => this.filters.every((filter) => this.evaluateFilter(item, filter))
+      );
+    }
+    if (this.sorts.length > 0) {
+      result = result.sort((a, b) => {
+        for (const sort of this.sorts) {
+          const comparison = this.evaluateSort(a, b, sort);
+          if (comparison !== 0) {
+            return comparison;
+          }
+        }
+        return 0;
+      });
+    }
+    if (this.skipCount !== void 0) {
+      result = result.slice(this.skipCount);
+    }
+    if (this.limitCount !== void 0) {
+      result = result.slice(0, this.limitCount);
+    }
+    return result;
+  }
+  async getWithRelations() {
+    const items = await this.get();
+    return Promise.all(
+      items.map(async (item) => {
+        const result = { ...item };
+        await Promise.all(
+          this.relations.map(async (relation) => {
+            const relatedData = await this.getRelatedData(item, relation);
+            const relationKey = `${relation}-data`;
+            result[relationKey] = relatedData;
+          })
+        );
+        return result;
+      })
+    );
+  }
+  async first() {
+    const items = await this.get();
+    return items[0] ?? null;
+  }
+  async firstWithRelations() {
+    const items = await this.getWithRelations();
+    return items[0] ?? null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentrainQuery
+});

package/dist/index.mjs

@@ -0,0 +1,185 @@
+// src/index.ts
+import { ContentrainCore } from "@contentrain/core";
+var ContentrainQuery = class {
+  constructor(core = new ContentrainCore(), collection) {
+    this.core = core;
+    this.collection = collection;
+  }
+  filters = [];
+  sorts = [];
+  relations = [];
+  limitCount;
+  skipCount;
+  where(field, operator, value) {
+    this.filters.push({ field, operator, value });
+    return this;
+  }
+  sort(field, direction = "asc") {
+    this.sorts.push({ field, direction });
+    return this;
+  }
+  take(limit) {
+    this.limitCount = limit;
+    return this;
+  }
+  offset(skip) {
+    this.skipCount = skip;
+    return this;
+  }
+  with(relation) {
+    this.relations.push(relation);
+    return this;
+  }
+  async getModelMetadata() {
+    return this.core.getModelMetadata(this.collection);
+  }
+  async getRelatedData(item, relation) {
+    const metadata = await this.getModelMetadata();
+    const fields = metadata.fields;
+    const fieldMetadata = fields.find((f) => f.id === relation);
+    if (!fieldMetadata) {
+      throw new Error(`Field ${relation} not found in model ${metadata.modelId}`);
+    }
+    if (!fieldMetadata.relation?.model) {
+      throw new Error(`Field ${relation} is not a relation`);
+    }
+    const relatedIds = item[relation];
+    if (!relatedIds) {
+      return null;
+    }
+    const relatedMetadata = await this.core.getModelMetadata(fieldMetadata.relation.model);
+    const hasLocalization = relatedMetadata.localization ?? false;
+    const locale = this.core.getLocale();
+    if (Array.isArray(relatedIds)) {
+      const relatedItems = await Promise.all(
+        relatedIds.map(async (id) => {
+          try {
+            const data = await this.core.getContentById(fieldMetadata.relation.model, id);
+            return hasLocalization && locale && typeof data === "object" && locale in data ? data[locale] : data;
+          } catch {
+            return null;
+          }
+        })
+      );
+      return relatedItems.filter((item2) => item2 !== null);
+    }
+    try {
+      const data = await this.core.getContentById(fieldMetadata.relation.model, relatedIds);
+      return hasLocalization && locale && typeof data === "object" && locale in data ? data[locale] : data;
+    } catch {
+      return null;
+    }
+  }
+  evaluateFilter(item, filter) {
+    const { field, operator, value } = filter;
+    const itemValue = item[field];
+    switch (operator) {
+      case "eq":
+        return itemValue === value;
+      case "neq":
+        return itemValue !== value;
+      case "gt":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue > value;
+      case "gte":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue >= value;
+      case "lt":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue < value;
+      case "lte":
+        return typeof itemValue === "number" && typeof value === "number" && itemValue <= value;
+      case "contains":
+        return typeof itemValue === "string" && typeof value === "string" && itemValue.includes(value);
+      case "startsWith":
+        return typeof itemValue === "string" && typeof value === "string" && itemValue.startsWith(value);
+      case "endsWith":
+        return typeof itemValue === "string" && typeof value === "string" && itemValue.endsWith(value);
+      case "in":
+        return Array.isArray(value) && value.includes(itemValue);
+      case "nin":
+        return Array.isArray(value) && !value.includes(itemValue);
+      case "exists":
+        return itemValue !== void 0 && itemValue !== null;
+      case "notExists":
+        return itemValue === void 0 || itemValue === null;
+      default:
+        return false;
+    }
+  }
+  evaluateSort(a, b, sort) {
+    const { field, direction } = sort;
+    const aValue = a[field];
+    const bValue = b[field];
+    if (aValue === bValue) {
+      return 0;
+    }
+    if (aValue === void 0 || aValue === null) {
+      return direction === "asc" ? -1 : 1;
+    }
+    if (bValue === void 0 || bValue === null) {
+      return direction === "asc" ? 1 : -1;
+    }
+    if (typeof aValue === "string" && typeof bValue === "string") {
+      return direction === "asc" ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
+    }
+    if (typeof aValue === "number" && typeof bValue === "number") {
+      return direction === "asc" ? aValue - bValue : bValue - aValue;
+    }
+    return 0;
+  }
+  async get() {
+    const metadata = await this.getModelMetadata();
+    const hasLocalization = metadata.localization ?? false;
+    const locale = this.core.getLocale();
+    const items = await this.core.getContent(this.collection);
+    let result = items.map((item) => hasLocalization && locale && typeof item === "object" && locale in item ? item[locale] : item);
+    if (this.filters.length > 0) {
+      result = result.filter(
+        (item) => this.filters.every((filter) => this.evaluateFilter(item, filter))
+      );
+    }
+    if (this.sorts.length > 0) {
+      result = result.sort((a, b) => {
+        for (const sort of this.sorts) {
+          const comparison = this.evaluateSort(a, b, sort);
+          if (comparison !== 0) {
+            return comparison;
+          }
+        }
+        return 0;
+      });
+    }
+    if (this.skipCount !== void 0) {
+      result = result.slice(this.skipCount);
+    }
+    if (this.limitCount !== void 0) {
+      result = result.slice(0, this.limitCount);
+    }
+    return result;
+  }
+  async getWithRelations() {
+    const items = await this.get();
+    return Promise.all(
+      items.map(async (item) => {
+        const result = { ...item };
+        await Promise.all(
+          this.relations.map(async (relation) => {
+            const relatedData = await this.getRelatedData(item, relation);
+            const relationKey = `${relation}-data`;
+            result[relationKey] = relatedData;
+          })
+        );
+        return result;
+      })
+    );
+  }
+  async first() {
+    const items = await this.get();
+    return items[0] ?? null;
+  }
+  async firstWithRelations() {
+    const items = await this.getWithRelations();
+    return items[0] ?? null;
+  }
+};
+export {
+  ContentrainQuery
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@contentrain/query",
+  "version": "1.0.0",
+  "private": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@contentrain/core": "workspace:*",
+    "@contentrain/types": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,146 @@
+import type { IContentrainCore } from '@contentrain/core';
+import type { ContentrainBaseModel, ContentrainModelMetadata } from '@contentrain/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ContentrainQuery } from './index';
+
+interface TestModel extends ContentrainBaseModel {
+  title: string
+  description: string
+  icon: string
+}
+
+describe('contentrain query', () => {
+  const mockCore: IContentrainCore = {
+    getModelMetadata: vi.fn(),
+    getContent: vi.fn(),
+    getContentById: vi.fn(),
+    getAvailableCollections: vi.fn(),
+    getLocale: vi.fn(),
+  };
+
+  const mockModelMetadata: ContentrainModelMetadata = {
+    modelId: 'processes',
+    fields: [
+      {
+        id: 'title',
+        type: 'string',
+        required: true,
+        componentId: 'single-line-text',
+      },
+      {
+        id: 'description',
+        type: 'string',
+        required: true,
+        componentId: 'multi-line-text',
+      },
+      {
+        id: 'icon',
+        type: 'string',
+        required: true,
+        componentId: 'single-line-text',
+      },
+    ],
+    localization: true,
+  };
+
+  const mockContent: TestModel = {
+    ID: '96c64803d441',
+    title: 'Research & Analysis',
+    description: 'We identify project goals and client needs, conducting in-depth analysis to develop the right, scalable solutions.',
+    icon: 'ri-search-eye-line',
+    createdAt: '2024-09-26T13:59:00.000Z',
+    updatedAt: '2024-10-14T06:46:13.160Z',
+    status: 'publish',
+    scheduled: false,
+  };
+
+  const mockLocalizedContent = {
+    tr: {
+      ID: '96c64803d441',
+      title: 'Araştırma ve Analiz',
+      description: 'Proje hedeflerini ve müşteri ihtiyaçlarını belirleyerek, doğru ve ölçeklenebilir çözümleri geliştirmek için analizler yapıyoruz.',
+      icon: 'ri-search-eye-line',
+      createdAt: '2024-09-26T13:59:00.000Z',
+      updatedAt: '2024-10-18T10:14:03.251Z',
+      status: 'publish',
+      scheduled: false,
+    },
+    en: {
+      ID: '96c64803d441',
+      title: 'Research & Analysis',
+      description: 'We identify project goals and client needs, conducting in-depth analysis to develop the right, scalable solutions.',
+      icon: 'ri-search-eye-line',
+      createdAt: '2024-09-26T13:59:00.000Z',
+      updatedAt: '2024-10-14T06:46:13.160Z',
+      status: 'publish',
+      scheduled: false,
+    },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should get content with filters', async () => {
+    vi.mocked(mockCore.getModelMetadata).mockResolvedValueOnce(mockModelMetadata);
+    vi.mocked(mockCore.getContent).mockResolvedValueOnce([mockContent]);
+
+    const query = new ContentrainQuery<TestModel>(mockCore, 'processes');
+    const result = await query.where('title', 'eq', 'Research & Analysis').get();
+
+    expect(result).toEqual([mockContent]);
+    expect(mockCore.getModelMetadata).toHaveBeenCalledTimes(1);
+    expect(mockCore.getContent).toHaveBeenCalledTimes(1);
+  });
+
+  it('should get content with sorting', async () => {
+    vi.mocked(mockCore.getModelMetadata).mockResolvedValueOnce(mockModelMetadata);
+    vi.mocked(mockCore.getContent).mockResolvedValueOnce([mockContent]);
+
+    const query = new ContentrainQuery<TestModel>(mockCore, 'processes');
+    const result = await query.sort('title', 'asc').get();
+
+    expect(result).toEqual([mockContent]);
+    expect(mockCore.getModelMetadata).toHaveBeenCalledTimes(1);
+    expect(mockCore.getContent).toHaveBeenCalledTimes(1);
+  });
+
+  it('should get content with pagination', async () => {
+    vi.mocked(mockCore.getModelMetadata).mockResolvedValueOnce(mockModelMetadata);
+    vi.mocked(mockCore.getContent).mockResolvedValueOnce([mockContent]);
+
+    const query = new ContentrainQuery<TestModel>(mockCore, 'processes');
+    const result = await query.take(1).offset(0).get();
+
+    expect(result).toEqual([mockContent]);
+    expect(mockCore.getModelMetadata).toHaveBeenCalledTimes(1);
+    expect(mockCore.getContent).toHaveBeenCalledTimes(1);
+  });
+
+  it('should get first item', async () => {
+    vi.mocked(mockCore.getModelMetadata).mockResolvedValueOnce(mockModelMetadata);
+    vi.mocked(mockCore.getContent).mockResolvedValueOnce([mockContent]);
+
+    const query = new ContentrainQuery<TestModel>(mockCore, 'processes');
+    const result = await query.first();
+
+    expect(result).toEqual(mockContent);
+    expect(mockCore.getModelMetadata).toHaveBeenCalledTimes(1);
+    expect(mockCore.getContent).toHaveBeenCalledTimes(1);
+  });
+
+  it('should handle localized content', async () => {
+    vi.mocked(mockCore.getModelMetadata).mockResolvedValueOnce(mockModelMetadata);
+    vi.mocked(mockCore.getContent).mockResolvedValueOnce([mockLocalizedContent]);
+    vi.mocked(mockCore.getLocale).mockReturnValue('tr');
+
+    const query = new ContentrainQuery<TestModel>(mockCore, 'processes');
+    const result = await query.get();
+
+    expect(result[0].title).toBe('Araştırma ve Analiz');
+    expect(result[0].description).toBe('Proje hedeflerini ve müşteri ihtiyaçlarını belirleyerek, doğru ve ölçeklenebilir çözümleri geliştirmek için analizler yapıyoruz.');
+    expect(mockCore.getModelMetadata).toHaveBeenCalledTimes(1);
+    expect(mockCore.getContent).toHaveBeenCalledTimes(1);
+    expect(mockCore.getLocale).toHaveBeenCalledTimes(1);
+  });
+});

package/src/index.ts

@@ -0,0 +1,233 @@
+import type { IContentrainCore } from '@contentrain/core';
+import type { ContentrainBaseModel, ContentrainModelMetadata, FilterCondition, SortCondition, SortDirection, WithRelation } from '@contentrain/types';
+import { ContentrainCore } from '@contentrain/core';
+
+export class ContentrainQuery<T extends ContentrainBaseModel> {
+  private filters: FilterCondition<T>[] = [];
+  private sorts: SortCondition<T>[] = [];
+  private relations: string[] = [];
+  private limitCount?: number;
+  private skipCount?: number;
+
+  constructor(
+    private core: IContentrainCore = new ContentrainCore(),
+    private collection: string,
+  ) { }
+
+  where(field: keyof T, operator: FilterCondition<T>['operator'], value: T[keyof T]): this {
+    this.filters.push({ field, operator, value });
+    return this;
+  }
+
+  sort(field: keyof T, direction: SortDirection = 'asc'): this {
+    this.sorts.push({ field, direction });
+    return this;
+  }
+
+  take(limit: number): this {
+    this.limitCount = limit;
+    return this;
+  }
+
+  offset(skip: number): this {
+    this.skipCount = skip;
+    return this;
+  }
+
+  with(relation: keyof T): this {
+    this.relations.push(relation as string);
+    return this;
+  }
+
+  private async getModelMetadata(): Promise<ContentrainModelMetadata> {
+    return this.core.getModelMetadata(this.collection);
+  }
+
+  private async getRelatedData(item: T, relation: string): Promise<ContentrainBaseModel | ContentrainBaseModel[] | null> {
+    const metadata = await this.getModelMetadata();
+    const fields = metadata.fields;
+    const fieldMetadata = fields.find(f => f.id === relation);
+
+    if (!fieldMetadata) {
+      throw new Error(`Field ${relation} not found in model ${metadata.modelId}`);
+    }
+
+    if (!fieldMetadata.relation?.model) {
+      throw new Error(`Field ${relation} is not a relation`);
+    }
+
+    const relatedIds = item[relation as keyof T];
+    if (!relatedIds) {
+      return null;
+    }
+
+    const relatedMetadata = await this.core.getModelMetadata(fieldMetadata.relation.model);
+    const hasLocalization = relatedMetadata.localization ?? false;
+    const locale = this.core.getLocale();
+
+    if (Array.isArray(relatedIds)) {
+      const relatedItems = await Promise.all(
+        relatedIds.map(async (id: string) => {
+          try {
+            const data = await this.core.getContentById<ContentrainBaseModel>(fieldMetadata.relation!.model, id);
+            return hasLocalization && locale && typeof data === 'object' && locale in data
+              ? (data as Record<string, ContentrainBaseModel>)[locale]
+              : data;
+          }
+          catch {
+            return null;
+          }
+        }),
+      );
+
+      return relatedItems.filter((item): item is ContentrainBaseModel => item !== null);
+    }
+
+    try {
+      const data = await this.core.getContentById<ContentrainBaseModel>(fieldMetadata.relation.model, relatedIds as string);
+      return hasLocalization && locale && typeof data === 'object' && locale in data
+        ? (data as Record<string, ContentrainBaseModel>)[locale]
+        : data;
+    }
+    catch {
+      return null;
+    }
+  }
+
+  private evaluateFilter(item: T, filter: FilterCondition<T>): boolean {
+    const { field, operator, value } = filter;
+    const itemValue = item[field];
+
+    switch (operator) {
+      case 'eq':
+        return itemValue === value;
+      case 'neq':
+        return itemValue !== value;
+      case 'gt':
+        return typeof itemValue === 'number' && typeof value === 'number' && itemValue > value;
+      case 'gte':
+        return typeof itemValue === 'number' && typeof value === 'number' && itemValue >= value;
+      case 'lt':
+        return typeof itemValue === 'number' && typeof value === 'number' && itemValue < value;
+      case 'lte':
+        return typeof itemValue === 'number' && typeof value === 'number' && itemValue <= value;
+      case 'contains':
+        return typeof itemValue === 'string' && typeof value === 'string' && itemValue.includes(value);
+      case 'startsWith':
+        return typeof itemValue === 'string' && typeof value === 'string' && itemValue.startsWith(value);
+      case 'endsWith':
+        return typeof itemValue === 'string' && typeof value === 'string' && itemValue.endsWith(value);
+      case 'in':
+        return Array.isArray(value) && value.includes(itemValue);
+      case 'nin':
+        return Array.isArray(value) && !value.includes(itemValue);
+      case 'exists':
+        return itemValue !== undefined && itemValue !== null;
+      case 'notExists':
+        return itemValue === undefined || itemValue === null;
+      default:
+        return false;
+    }
+  }
+
+  private evaluateSort(a: T, b: T, sort: SortCondition<T>): number {
+    const { field, direction } = sort;
+    const aValue = a[field];
+    const bValue = b[field];
+
+    if (aValue === bValue) {
+      return 0;
+    }
+
+    if (aValue === undefined || aValue === null) {
+      return direction === 'asc' ? -1 : 1;
+    }
+
+    if (bValue === undefined || bValue === null) {
+      return direction === 'asc' ? 1 : -1;
+    }
+
+    if (typeof aValue === 'string' && typeof bValue === 'string') {
+      return direction === 'asc'
+        ? aValue.localeCompare(bValue)
+        : bValue.localeCompare(aValue);
+    }
+
+    if (typeof aValue === 'number' && typeof bValue === 'number') {
+      return direction === 'asc'
+        ? aValue - bValue
+        : bValue - aValue;
+    }
+
+    return 0;
+  }
+
+  async get(): Promise<T[]> {
+    const metadata = await this.getModelMetadata();
+    const hasLocalization = metadata.localization ?? false;
+    const locale = this.core.getLocale();
+
+    const items = await this.core.getContent<Record<string, unknown>>(this.collection);
+    let result = items.map(item => hasLocalization && locale && typeof item === 'object' && locale in item
+      ? (item as Record<string, T>)[locale]
+      : item as T);
+
+    if (this.filters.length > 0) {
+      result = result.filter(item =>
+        this.filters.every(filter => this.evaluateFilter(item, filter)),
+      );
+    }
+
+    if (this.sorts.length > 0) {
+      result = result.sort((a, b) => {
+        for (const sort of this.sorts) {
+          const comparison = this.evaluateSort(a, b, sort);
+          if (comparison !== 0) {
+            return comparison;
+          }
+        }
+        return 0;
+      });
+    }
+
+    if (this.skipCount !== undefined) {
+      result = result.slice(this.skipCount);
+    }
+
+    if (this.limitCount !== undefined) {
+      result = result.slice(0, this.limitCount);
+    }
+
+    return result;
+  }
+
+  async getWithRelations<K extends keyof T>(): Promise<WithRelation<T, K>[]> {
+    const items = await this.get();
+
+    return Promise.all(
+      items.map(async (item) => {
+        const result = { ...item } as WithRelation<T, K>;
+
+        await Promise.all(
+          this.relations.map(async (relation) => {
+            const relatedData = await this.getRelatedData(item, relation);
+            const relationKey = `${relation}-data` as keyof WithRelation<T, K>;
+            result[relationKey] = relatedData as any;
+          }),
+        );
+
+        return result;
+      }),
+    );
+  }
+
+  async first(): Promise<T | null> {
+    const items = await this.get();
+    return items[0] ?? null;
+  }
+
+  async firstWithRelations<K extends keyof T>(): Promise<WithRelation<T, K> | null> {
+    const items = await this.getWithRelations<K>();
+    return items[0] ?? null;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});