@mybe/sdk 1.0.2 → 1.0.5

package/README.md

@@ -1,366 +1,546 @@
-# Mybe CMS SDK
-
-A TypeScript SDK for fetching content from Mybe CMS.
-
-## Installation
-
-```bash
-npm install @mybe/sdk
-```
-
-## Features
-
-- ✅ **Zero Dependencies** - Uses native fetch API
-- ✅ **TypeScript Support** - Full type safety with TypeScript
-- ✅ **Auto Environment Detection** - Automatically detects development vs production
-- ✅ **Error Handling** - Custom error classes for better error handling
-- ✅ **Pagination Support** - Built-in pagination for large datasets
-- ✅ **Status Filtering** - Filter content by status (draft, published, archived)
-- ✅ **Locale Filtering** - Filter content by locale for multi-language support
-
-## Quick Start
-
-```typescript
-import { MybeSDK } from '@mybe/sdk';
-
-// Initialize the SDK
-const sdk = new MybeSDK({
-  apiKey: 'your-api-key'
-});
-
-// Fetch a single content entry
-const content = await sdk.getContent('content-id');
-
-// Fetch content by type with filters
-const contentList = await sdk.getContentByType('content-type-id', {
-  status: 'published',
-  limit: 10
-});
-```
-
-## Configuration
-
-### Basic Configuration
-
-```typescript
-const sdk = new MybeSDK({
-  apiKey: 'your-api-key'
-});
-```
-
-The SDK automatically detects the environment:
-- **Development** (`NODE_ENV=development`): Uses `http://localhost:3001/api/v1`
-- **Production**: Uses `https://fizsdck7l0.execute-api.us-east-1.amazonaws.com/dev/api/v1`
-
-> **Note:** The production endpoint uses AWS API Gateway REST API with API key validation and automatic usage tracking.
-
-### Custom Base URL (Optional)
-
-```typescript
-const sdk = new MybeSDK({
-  apiKey: 'your-api-key',
-  baseUrl: 'https://custom-api.example.com/api/v1'
-});
-```
-
-## API Reference
-
-### Content Models (Content Types)
-
-#### `getContentModels(projectId: string)`
-
-Get all content models for a project.
-
-```typescript
-const contentModels = await sdk.getContentModels('project-id');
-```
-
-**Returns:** `Promise<ContentType[]>`
-
-#### `getContentModel(contentTypeId: string)`
-
-Get a specific content model by ID.
-
-```typescript
-const contentModel = await sdk.getContentModel('content-type-id');
-```
-
-**Returns:** `Promise<ContentType>`
-
-### Content Entries
-
-#### `getContent(contentId: string)`
-
-Get a single content entry by ID.
-
-```typescript
-const content = await sdk.getContent('content-id');
-```
-
-**Returns:** `Promise<ContentEntry>`
-
-#### `getContentByType(contentTypeId: string, options?: ContentFilterOptions)`
-
-Get all content entries for a specific content type.
-
-```typescript
-const result = await sdk.getContentByType('content-type-id', {
-  status: 'published',
-  limit: 20,
-  lastKey: 'pagination-key' // For pagination
-});
-
-console.log(result.data); // Array of content entries
-console.log(result.pagination.hasMore); // Boolean
-console.log(result.pagination.lastEvaluatedKey); // For next page
-```
-
-**Options:**
-- `status?: 'draft' | 'published' | 'archived'` - Filter by status
-- `locale?: string` - Filter by locale (e.g., 'en-US', 'bn-BD', 'fr-FR', 'es-ES')
-- `limit?: number` - Number of items per page
-- `lastKey?: string` - Pagination key from previous response
-
-**Returns:** `Promise<ContentListResponse>`
-
-#### `getContentByProject(projectId: string, options?: ContentFilterOptions)`
-
-Get all content entries for a project.
-
-```typescript
-const result = await sdk.getContentByProject('project-id', {
-  status: 'published',
-  limit: 20
-});
-```
-
-**Options:**
-- `status?: 'draft' | 'published' | 'archived'` - Filter by status
-- `locale?: string` - Filter by locale (e.g., 'en-US', 'bn-BD', 'fr-FR', 'es-ES')
-- `limit?: number` - Number of items per page
-- `lastKey?: string` - Pagination key from previous response
-
-**Returns:** `Promise<ContentListResponse>`
-
-## Pagination Example
-
-```typescript
-let lastKey: string | undefined;
-let allContent: ContentEntry[] = [];
-
-do {
-  const result = await sdk.getContentByType('content-type-id', {
-    status: 'published',
-    limit: 50,
-    lastKey: lastKey ? JSON.stringify(result.pagination.lastEvaluatedKey) : undefined
-  });
-
-  allContent = [...allContent, ...result.data];
-  lastKey = result.pagination.hasMore 
-    ? JSON.stringify(result.pagination.lastEvaluatedKey) 
-    : undefined;
-
-} while (lastKey);
-
-console.log(`Fetched ${allContent.length} total items`);
-```
-
-## Error Handling
-
-The SDK provides custom error classes for better error handling:
-
-```typescript
-import { 
-  MybeSDK, 
-  NotFoundError, 
-  UnauthorizedError,
-  ValidationError,
-  ServerError 
-} from '@mybe/sdk';
-
-try {
-  const content = await sdk.getContent('content-id');
-} catch (error) {
-  if (error instanceof NotFoundError) {
-    console.error('Content not found');
-  } else if (error instanceof UnauthorizedError) {
-    console.error('Invalid API key');
-  } else if (error instanceof ValidationError) {
-    console.error('Validation error:', error.message);
-  } else if (error instanceof ServerError) {
-    console.error('Server error:', error.message);
-  } else {
-    console.error('Unknown error:', error);
-  }
-}
-```
-
-### Error Types
-
-- `MybeSDKError` - Base error class
-- `NotFoundError` - Resource not found (404)
-- `UnauthorizedError` - Invalid API key (401)
-- `ForbiddenError` - Insufficient permissions (403)
-- `ValidationError` - Validation failed (400)
-- `ServerError` - Internal server error (500)
-
-## TypeScript Types
-
-The SDK exports all TypeScript types for your convenience:
-
-```typescript
-import type {
-  ContentType,
-  ContentEntry,
-  ContentFilterOptions,
-  PaginationResponse,
-  APIResponse,
-  ContentListResponse
-} from '@mybe/sdk';
-```
-
-### ContentType
-
-```typescript
-interface ContentType {
-  id: string;
-  project_id: string;
-  name: string;
-  slug: string;
-  description?: string;
-  created_at: string;
-  updated_at: string;
-}
-```
-
-### ContentEntry
-
-```typescript
-interface ContentEntry {
-  id: string;
-  content_type_id: string;
-  project_id: string;
-  slug?: string;
-  status: 'draft' | 'published' | 'archived';
-  data: Record<string, any>;
-  locale?: string;
-  created_by: string;
-  updated_by?: string;
-  published_at?: string;
-  created_at: string;
-  updated_at: string;
-}
-```
-
-## Examples
-
-### Fetch Published Blog Posts
-
-```typescript
-const sdk = new MybeSDK({ apiKey: 'your-api-key' });
-
-const posts = await sdk.getContentByType('blog-post-type-id', {
-  status: 'published',
-  limit: 10
-});
-
-posts.data.forEach(post => {
-  console.log(post.data.title);
-  console.log(post.data.content);
-});
-```
-
-### Fetch All Content Models
-
-```typescript
-const contentModels = await sdk.getContentModels('project-id');
-
-contentModels.forEach(model => {
-  console.log(`${model.name} (${model.slug})`);
-});
-```
-
-### Fetch Single Content Entry
-
-```typescript
-const content = await sdk.getContent('content-entry-id');
-
-console.log(content.data); // Your content data
-console.log(content.status); // draft | published | archived
-```
-
-### Multi-locale Content
-
-Fetch content in different languages using the locale filter:
-
-```typescript
-const sdk = new MybeSDK({ apiKey: 'your-api-key' });
-
-// Fetch English content
-const englishPosts = await sdk.getContentByType('blog-post-type-id', {
-  status: 'published',
-  locale: 'en-US',
-  limit: 10
-});
-
-// Fetch Bangla content
-const banglaPosts = await sdk.getContentByType('blog-post-type-id', {
-  status: 'published',
-  locale: 'bn-BD',
-  limit: 10
-});
-
-// Fetch French content
-const frenchPosts = await sdk.getContentByType('blog-post-type-id', {
-  status: 'published',
-  locale: 'fr-FR',
-  limit: 10
-});
-
-// Fetch Spanish content
-const spanishPosts = await sdk.getContentByType('blog-post-type-id', {
-  status: 'published',
-  locale: 'es-ES',
-  limit: 10
-});
-```
-
-**Building a Multi-language Website:**
-
-```typescript
-// Get user's preferred language
-const userLocale = getUserPreferredLocale(); // e.g., 'bn-BD'
-
-// Fetch content in user's language
-const localizedContent = await sdk.getContentByType('content-type-id', {
-  status: 'published',
-  locale: userLocale,
-  limit: 20
-});
-
-// Display localized content
-localizedContent.data.forEach(item => {
-  console.log(item.data.title); // Title in user's language
-  console.log(item.metadata.locale); // e.g., 'bn-BD'
-});
-```
-
-**Supported Locales:**
-- `en-US` - English (United States)
-- `bn-BD` - Bangla (Bangladesh)
-- `fr-FR` - French (France)
-- `es-ES` - Spanish (Spain)
-- Custom locales as configured in your CMS
-
-## Requirements
-
-- Node.js 18+ (for native fetch support)
-- TypeScript 5.0+ (for development)
-
-## License
-
-MIT
-
-## Support
-
-For issues and questions, please visit the [GitHub repository](https://github.com/MyBeeInovationLabs/mybe-cms).
+# Mybe CMS SDK
+
+A TypeScript SDK for fetching content from Mybe CMS.
+
+## Installation
+
+```bash
+npm install @mybe/sdk
+```
+
+## Features
+
+- ✅ **Zero Dependencies** - Uses native fetch API
+- ✅ **TypeScript Support** - Full type safety with TypeScript
+- ✅ **Auto Environment Detection** - Automatically detects development vs production
+- ✅ **Error Handling** - Custom error classes for better error handling
+- ✅ **Pagination Support** - Built-in pagination for large datasets
+- ✅ **Status Filtering** - Filter content by status (draft, published, archived)
+- ✅ **Locale Filtering** - Filter content by locale for multi-language support
+- ✅ **GraphQL Support** - Powerful GraphQL API for flexible data querying
+
+## Quick Start
+
+```typescript
+import { MybeSDK } from '@mybe/sdk';
+
+// Initialize the SDK
+const sdk = new MybeSDK({
+  apiKey: 'your-api-key'
+});
+
+// Fetch a single content entry
+const content = await sdk.getContent('content-id');
+
+// Fetch content by type with filters
+const contentList = await sdk.getContentByType('content-type-id', {
+  status: 'published',
+  limit: 10
+});
+```
+
+## Configuration
+
+### Basic Configuration
+
+```typescript
+const sdk = new MybeSDK({
+  apiKey: 'your-api-key'
+});
+```
+
+The SDK automatically detects the environment:
+- **Development** (`NODE_ENV=development`): Uses `https://sdk-dev.contensa.ai/dev/api/v1`
+- **Production**: Uses `https://sdk-dev.contensa.ai/dev/api/v1`
+
+> **Note:** The SDK uses a custom domain for all environments, providing a professional branded URL while hiding the underlying AWS infrastructure. Both development and production currently point to the same endpoint temporarily.
+
+### Custom Base URL (Optional)
+
+```typescript
+const sdk = new MybeSDK({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://custom-api.example.com/api/v1'
+});
+```
+
+## API Reference
+
+### Content Models (Content Types)
+
+#### `getContentModels(projectId: string)`
+
+Get all content models for a project.
+
+```typescript
+const contentModels = await sdk.getContentModels('project-id');
+```
+
+**Returns:** `Promise<ContentType[]>`
+
+#### `getContentModel(contentTypeId: string)`
+
+Get a specific content model by ID.
+
+```typescript
+const contentModel = await sdk.getContentModel('content-type-id');
+```
+
+**Returns:** `Promise<ContentType>`
+
+### Content Entries
+
+#### `getContent(contentId: string)`
+
+Get a single content entry by ID.
+
+```typescript
+const content = await sdk.getContent('content-id');
+```
+
+**Returns:** `Promise<ContentEntry>`
+
+#### `getContentByType(contentTypeId: string, options?: ContentFilterOptions)`
+
+Get all content entries for a specific content type.
+
+```typescript
+const result = await sdk.getContentByType('content-type-id', {
+  status: 'published',
+  limit: 20,
+  lastKey: 'pagination-key' // For pagination
+});
+
+console.log(result.data); // Array of content entries
+console.log(result.pagination.hasMore); // Boolean
+console.log(result.pagination.lastEvaluatedKey); // For next page
+```
+
+**Options:**
+- `status?: 'draft' | 'published' | 'archived'` - Filter by status
+- `locale?: string` - Filter by locale (e.g., 'en-US', 'bn-BD', 'fr-FR', 'es-ES')
+- `limit?: number` - Number of items per page
+- `lastKey?: string` - Pagination key from previous response
+
+**Returns:** `Promise<ContentListResponse>`
+
+#### `getContentByProject(projectId: string, options?: ContentFilterOptions)`
+
+Get all content entries for a project.
+
+```typescript
+const result = await sdk.getContentByProject('project-id', {
+  status: 'published',
+  limit: 20
+});
+```
+
+**Options:**
+- `status?: 'draft' | 'published' | 'archived'` - Filter by status
+- `locale?: string` - Filter by locale (e.g., 'en-US', 'bn-BD', 'fr-FR', 'es-ES')
+- `limit?: number` - Number of items per page
+- `lastKey?: string` - Pagination key from previous response
+
+**Returns:** `Promise<ContentListResponse>`
+
+## Pagination Example
+
+```typescript
+let lastKey: string | undefined;
+let allContent: ContentEntry[] = [];
+
+do {
+  const result = await sdk.getContentByType('content-type-id', {
+    status: 'published',
+    limit: 50,
+    lastKey: lastKey ? JSON.stringify(result.pagination.lastEvaluatedKey) : undefined
+  });
+
+  allContent = [...allContent, ...result.data];
+  lastKey = result.pagination.hasMore 
+    ? JSON.stringify(result.pagination.lastEvaluatedKey) 
+    : undefined;
+
+} while (lastKey);
+
+console.log(`Fetched ${allContent.length} total items`);
+```
+
+## Error Handling
+
+The SDK provides custom error classes for better error handling:
+
+```typescript
+import { 
+  MybeSDK, 
+  NotFoundError, 
+  UnauthorizedError,
+  ValidationError,
+  ServerError 
+} from '@mybe/sdk';
+
+try {
+  const content = await sdk.getContent('content-id');
+} catch (error) {
+  if (error instanceof NotFoundError) {
+    console.error('Content not found');
+  } else if (error instanceof UnauthorizedError) {
+    console.error('Invalid API key');
+  } else if (error instanceof ValidationError) {
+    console.error('Validation error:', error.message);
+  } else if (error instanceof ServerError) {
+    console.error('Server error:', error.message);
+  } else {
+    console.error('Unknown error:', error);
+  }
+}
+```
+
+### Error Types
+
+- `MybeSDKError` - Base error class
+- `NotFoundError` - Resource not found (404)
+- `UnauthorizedError` - Invalid API key (401)
+- `ForbiddenError` - Insufficient permissions (403)
+- `ValidationError` - Validation failed (400)
+- `ServerError` - Internal server error (500)
+
+## TypeScript Types
+
+The SDK exports all TypeScript types for your convenience:
+
+```typescript
+import type {
+  ContentType,
+  ContentEntry,
+  ContentFilterOptions,
+  PaginationResponse,
+  APIResponse,
+  ContentListResponse
+} from '@mybe/sdk';
+```
+
+### ContentType
+
+```typescript
+interface ContentType {
+  id: string;
+  project_id: string;
+  name: string;
+  slug: string;
+  description?: string;
+  created_at: string;
+  updated_at: string;
+}
+```
+
+### ContentEntry
+
+```typescript
+interface ContentEntry {
+  id: string;
+  content_type_id: string;
+  project_id: string;
+  slug?: string;
+  status: 'draft' | 'published' | 'archived';
+  data: Record<string, any>;
+  locale?: string;
+  created_by: string;
+  updated_by?: string;
+  published_at?: string;
+  created_at: string;
+  updated_at: string;
+}
+```
+
+## Examples
+
+### Fetch Published Blog Posts
+
+```typescript
+const sdk = new MybeSDK({ apiKey: 'your-api-key' });
+
+const posts = await sdk.getContentByType('blog-post-type-id', {
+  status: 'published',
+  limit: 10
+});
+
+posts.data.forEach(post => {
+  console.log(post.data.title);
+  console.log(post.data.content);
+});
+```
+
+### Fetch All Content Models
+
+```typescript
+const contentModels = await sdk.getContentModels('project-id');
+
+contentModels.forEach(model => {
+  console.log(`${model.name} (${model.slug})`);
+});
+```
+
+### Fetch Single Content Entry
+
+```typescript
+const content = await sdk.getContent('content-entry-id');
+
+console.log(content.data); // Your content data
+console.log(content.status); // draft | published | archived
+```
+
+### Multi-locale Content
+
+Fetch content in different languages using the locale filter:
+
+```typescript
+const sdk = new MybeSDK({ apiKey: 'your-api-key' });
+
+// Fetch English content
+const englishPosts = await sdk.getContentByType('blog-post-type-id', {
+  status: 'published',
+  locale: 'en-US',
+  limit: 10
+});
+
+// Fetch Bangla content
+const banglaPosts = await sdk.getContentByType('blog-post-type-id', {
+  status: 'published',
+  locale: 'bn-BD',
+  limit: 10
+});
+
+// Fetch French content
+const frenchPosts = await sdk.getContentByType('blog-post-type-id', {
+  status: 'published',
+  locale: 'fr-FR',
+  limit: 10
+});
+
+// Fetch Spanish content
+const spanishPosts = await sdk.getContentByType('blog-post-type-id', {
+  status: 'published',
+  locale: 'es-ES',
+  limit: 10
+});
+```
+
+**Building a Multi-language Website:**
+
+```typescript
+// Get user's preferred language
+const userLocale = getUserPreferredLocale(); // e.g., 'bn-BD'
+
+// Fetch content in user's language
+const localizedContent = await sdk.getContentByType('content-type-id', {
+  status: 'published',
+  locale: userLocale,
+  limit: 20
+});
+
+// Display localized content
+localizedContent.data.forEach(item => {
+  console.log(item.data.title); // Title in user's language
+  console.log(item.metadata.locale); // e.g., 'bn-BD'
+});
+```
+
+**Supported Locales:**
+- `en-US` - English (United States)
+- `bn-BD` - Bangla (Bangladesh)
+- `fr-FR` - French (France)
+- `es-ES` - Spanish (Spain)
+- Custom locales as configured in your CMS
+
+## GraphQL API
+
+Mybe CMS provides a powerful GraphQL API for flexible data querying. Use GraphQL when you need advanced filtering, want to request specific fields only, or prefer the GraphQL query language.
+
+### Quick Start with GraphQL
+
+```typescript
+import { MybeSDK } from '@mybe/sdk';
+
+const sdk = new MybeSDK({ apiKey: 'your-api-key' });
+const PROJECT_ID = 'your-project-id';
+
+// Execute a GraphQL query
+const result = await sdk.graphql(PROJECT_ID, `
+  query {
+    blogPostCollection(limit: 10, where: { status: "published" }) {
+      items {
+        id
+        slug
+        data
+      }
+      total
+    }
+  }
+`);
+
+console.log(result.blogPostCollection.items);
+```
+
+### GraphQL Method
+
+#### `graphql<T>(projectId: string, query: string, variables?: Record<string, any>)`
+
+Execute a GraphQL query against your project.
+
+**Parameters:**
+- `projectId` - Your project ID
+- `query` - GraphQL query string
+- `variables` - Optional query variables (recommended for dynamic queries)
+
+**Returns:** `Promise<T>` - The data from your GraphQL query
+
+### GraphQL Examples
+
+#### Basic Collection Query
+
+```typescript
+const { blogPostCollection } = await sdk.graphql(PROJECT_ID, `
+  query {
+    blogPostCollection(limit: 5) {
+      items {
+        id
+        slug
+        status
+        data
+        published_at
+      }
+      total
+    }
+  }
+`);
+
+console.log(`Total posts: ${blogPostCollection.total}`);
+blogPostCollection.items.forEach(post => {
+  console.log(post.data.title);
+});
+```
+
+#### Filter by Status
+
+```typescript
+const { blogPostCollection } = await sdk.graphql(PROJECT_ID, `
+  query {
+    blogPostCollection(where: { status: "published" }) {
+      items {
+        id
+        slug
+        data
+      }
+    }
+  }
+`);
+```
+
+#### Get Single Entry by ID
+
+```typescript
+const { blogPost } = await sdk.graphql(PROJECT_ID, `
+  query {
+    blogPost(id: "entry-123") {
+      id
+      slug
+      status
+      data
+      created_at
+      published_at
+    }
+  }
+`);
+```
+
+#### Using Variables (Recommended)
+
+```typescript
+const result = await sdk.graphql(
+  PROJECT_ID,
+  `
+    query GetPostBySlug($slug: String!) {
+      blogPostCollection(where: { slug: $slug }) {
+        items {
+          id
+          slug
+          data
+        }
+      }
+    }
+  `,
+  { slug: 'my-blog-post' }
+);
+
+const post = result.blogPostCollection.items[0];
+```
+
+#### Pagination with GraphQL
+
+```typescript
+// Page 1
+const page1 = await sdk.graphql(PROJECT_ID, `
+  query {
+    blogPostCollection(limit: 10, skip: 0) {
+      items { id slug }
+      total
+    }
+  }
+`);
+
+// Page 2
+const page2 = await sdk.graphql(PROJECT_ID, `
+  query {
+    blogPostCollection(limit: 10, skip: 10) {
+      items { id slug }
+      total
+    }
+  }
+`);
+```
+
+### REST vs GraphQL - When to Use
+
+**Use REST When:**
+- ✅ Simple queries (get by ID, get all)
+- ✅ You want straightforward API calls
+- ✅ You prefer SDK helper methods
+- ✅ You need full object responses
+
+**Use GraphQL When:**
+- ✅ Complex filtering requirements
+- ✅ You need specific fields only (reduce payload size)
+- ✅ Multiple queries in one request
+- ✅ You want flexible, ad-hoc queries
+- ✅ Your frontend uses Apollo Client or similar
+
+### Complete GraphQL Guide
+
+For comprehensive GraphQL documentation, examples, and best practices, see:
+- **[GraphQL API Guide](./GRAPHQL_GUIDE.md)** - Complete GraphQL documentation
+- **[Test Examples](./test-graphql.ts)** - Working code examples
+
+### GraphQL Schema
+
+Your GraphQL schema is automatically generated from your content types. For example:
+
+**Content Type:** "Blog Post"  
+**Generates:**
+- `blogPost(id: ID!)` - Get single entry
+- `blogPostCollection(limit, skip, where)` - Get collection
+
+**Naming:** Content type names are converted to camelCase (e.g., "Blog Post" → `blogPost`)
+
+## Requirements
+
+- Node.js 18+ (for native fetch support)
+- TypeScript 5.0+ (for development)
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit the [GitHub repository](https://github.com/MyBeeInovationLabs/mybe-cms).

package/dist/client.d.ts

@@ -7,6 +7,32 @@ export declare class MybeSDK {
      * Make HTTP request to API
      */
     private request;
+    /**
+     * Convert kebab-case to camelCase for GraphQL field names
+     * Examples:
+     *   "blog-post" → "blogPost"
+     *   "case-study" → "caseStudy"
+     *   "product" → "product" (unchanged)
+     */
+    private toCamelCase;
+    /**
+     * Automatically convert kebab-case content type slugs to camelCase in GraphQL queries
+     * This allows users to use their actual content type slugs (e.g., "blog-post")
+     * without needing to know about GraphQL's camelCase requirement
+     *
+     * Converts patterns like:
+     *   "blog-post" → "blogPost"
+     *   "blog-postCollection" → "blogPostCollection"
+     *   "case-study(" → "caseStudy("
+     *
+     * @returns Object with converted query and mapping of original to converted field names
+     */
+    private convertQuerySlugs;
+    /**
+     * Convert response keys back to the original format used in the query
+     * This allows users to access response fields using the same kebab-case format they used in the query
+     */
+    private convertResponseKeys;
     /**
      * Build query string from options
      */
@@ -31,4 +57,65 @@ export declare class MybeSDK {
      * Get all content entries for a project
      */
     getContentByProject(projectId: string, options?: ContentFilterOptions): Promise<ContentListResponse>;
+    /**
+     * Get a single content entry by field value
+     * Similar to Contentful's getEntries with field filters
+     * @example
+     * // Get service by href field
+     * const service = await sdk.getContentByField('service-type-id', 'href', '/services/web-dev');
+     *
+     * // Get blog post by slug field
+     * const post = await sdk.getContentByField('blog-type-id', 'slug', 'my-first-post');
+     */
+    getContentByField(contentTypeId: string, fieldName: string, fieldValue: string): Promise<ContentEntry | null>;
+    /**
+     * Execute a GraphQL query against your project
+     *
+     * Provides flexible, powerful querying capabilities for your content.
+     * GraphQL allows you to request exactly the data you need in a single request.
+     *
+     * @param projectId - Your project ID
+     * @param query - GraphQL query string
+     * @param variables - Optional query variables for parameterized queries
+     *
+     * @example
+     * // Get published blog posts
+     * const result = await sdk.graphql('project-id', `
+     *   query {
+     *     blogPostCollection(limit: 10, where: { status: "published" }) {
+     *       items {
+     *         id
+     *         slug
+     *         data
+     *       }
+     *       total
+     *     }
+     *   }
+     * `);
+     *
+     * @example
+     * // Get a single entry by ID
+     * const result = await sdk.graphql('project-id', `
+     *   query {
+     *     blogPost(id: "entry-123") {
+     *       id
+     *       slug
+     *       status
+     *       data
+     *       published_at
+     *     }
+     *   }
+     * `);
+     *
+     * @example
+     * // Using variables for safer queries
+     * const result = await sdk.graphql('project-id', `
+     *   query GetPost($slug: String!) {
+     *     blogPostCollection(where: { slug: $slug }) {
+     *       items { id data }
+     *     }
+     *   }
+     * `, { slug: 'my-post' });
+     */
+    graphql<T = any>(projectId: string, query: string, variables?: Record<string, any>): Promise<T>;
 }

package/dist/client.js

@@ -13,10 +13,12 @@ export class MybeSDK {
         else {
             const isDevelopment = typeof process !== 'undefined' &&
                 process.env.NODE_ENV === 'development';
-            // Use REST API endpoint for production (with API key validation and usage tracking)
+            // Use custom domain for SDK endpoints
+            // TODO: Update production URL when production custom domain is ready
+            // Production: https://fizsdck7l0.execute-api.us-east-1.amazonaws.com/dev/api/v1
             this.baseUrl = isDevelopment
-                ? 'http://localhost:3001/api/v1'
-                : 'https://fizsdck7l0.execute-api.us-east-1.amazonaws.com/dev/api/v1';
+                ? 'https://sdk-dev.contensa.ai/dev/api/v1'
+                : 'https://sdk-dev.contensa.ai/dev/api/v1'; // Using dev URL for both temporarily
         }
     }
     /**
@@ -69,6 +71,65 @@ export class MybeSDK {
             throw new MybeSDKError('An unknown error occurred');
         }
     }
+    /**
+     * Convert kebab-case to camelCase for GraphQL field names
+     * Examples:
+     *   "blog-post" → "blogPost"
+     *   "case-study" → "caseStudy"
+     *   "product" → "product" (unchanged)
+     */
+    toCamelCase(str) {
+        return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+    /**
+     * Automatically convert kebab-case content type slugs to camelCase in GraphQL queries
+     * This allows users to use their actual content type slugs (e.g., "blog-post")
+     * without needing to know about GraphQL's camelCase requirement
+     *
+     * Converts patterns like:
+     *   "blog-post" → "blogPost"
+     *   "blog-postCollection" → "blogPostCollection"
+     *   "case-study(" → "caseStudy("
+     *
+     * @returns Object with converted query and mapping of original to converted field names
+     */
+    convertQuerySlugs(query) {
+        const fieldMap = new Map();
+        // Match kebab-case slugs followed by Collection, (, {, or whitespace
+        const convertedQuery = query.replace(/([a-z]+(?:-[a-z]+)+)(Collection|\(|{|\s)/gi, (match, slug, suffix) => {
+            const camelCaseSlug = this.toCamelCase(slug);
+            const originalField = slug + suffix.replace(/[\(\{\s]/, ''); // Extract just 'Collection' if present
+            const convertedField = camelCaseSlug + suffix.replace(/[\(\{\s]/, '');
+            // Store mapping if it's a field name (with Collection or standalone)
+            if (suffix === 'Collection' || suffix === '(' || suffix === ' ' || suffix === '{') {
+                // Map both with and without Collection
+                fieldMap.set(camelCaseSlug, slug);
+                fieldMap.set(camelCaseSlug + 'Collection', slug + 'Collection');
+                fieldMap.set(camelCaseSlug + 'Collection', slug + 'Collection');
+            }
+            return camelCaseSlug + suffix;
+        });
+        return { query: convertedQuery, fieldMap };
+    }
+    /**
+     * Convert response keys back to the original format used in the query
+     * This allows users to access response fields using the same kebab-case format they used in the query
+     */
+    convertResponseKeys(data, fieldMap) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        if (Array.isArray(data)) {
+            return data.map(item => this.convertResponseKeys(item, fieldMap));
+        }
+        const converted = {};
+        for (const [key, value] of Object.entries(data)) {
+            // Check if this key should be converted back
+            const originalKey = fieldMap.get(key) || key;
+            converted[originalKey] = this.convertResponseKeys(value, fieldMap);
+        }
+        return converted;
+    }
     /**
      * Build query string from options
      */
@@ -126,4 +187,109 @@ export class MybeSDK {
         const queryString = this.buildQueryString(options);
         return await this.request(`/content-entry/project/${projectId}${queryString}`);
     }
+    /**
+     * Get a single content entry by field value
+     * Similar to Contentful's getEntries with field filters
+     * @example
+     * // Get service by href field
+     * const service = await sdk.getContentByField('service-type-id', 'href', '/services/web-dev');
+     *
+     * // Get blog post by slug field
+     * const post = await sdk.getContentByField('blog-type-id', 'slug', 'my-first-post');
+     */
+    async getContentByField(contentTypeId, fieldName, fieldValue) {
+        try {
+            const encodedValue = encodeURIComponent(fieldValue);
+            const response = await this.request(`/type/${contentTypeId}/field/${fieldName}/${encodedValue}`);
+            return response.data;
+        }
+        catch (error) {
+            // If it's a 404, return null instead of throwing
+            if (error instanceof NotFoundError) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute a GraphQL query against your project
+     *
+     * Provides flexible, powerful querying capabilities for your content.
+     * GraphQL allows you to request exactly the data you need in a single request.
+     *
+     * @param projectId - Your project ID
+     * @param query - GraphQL query string
+     * @param variables - Optional query variables for parameterized queries
+     *
+     * @example
+     * // Get published blog posts
+     * const result = await sdk.graphql('project-id', `
+     *   query {
+     *     blogPostCollection(limit: 10, where: { status: "published" }) {
+     *       items {
+     *         id
+     *         slug
+     *         data
+     *       }
+     *       total
+     *     }
+     *   }
+     * `);
+     *
+     * @example
+     * // Get a single entry by ID
+     * const result = await sdk.graphql('project-id', `
+     *   query {
+     *     blogPost(id: "entry-123") {
+     *       id
+     *       slug
+     *       status
+     *       data
+     *       published_at
+     *     }
+     *   }
+     * `);
+     *
+     * @example
+     * // Using variables for safer queries
+     * const result = await sdk.graphql('project-id', `
+     *   query GetPost($slug: String!) {
+     *     blogPostCollection(where: { slug: $slug }) {
+     *       items { id data }
+     *     }
+     *   }
+     * `, { slug: 'my-post' });
+     */
+    async graphql(projectId, query, variables) {
+        try {
+            // Automatically convert kebab-case slugs to camelCase for GraphQL
+            const { query: processedQuery, fieldMap } = this.convertQuerySlugs(query);
+            const response = await this.request('/graphql', {
+                method: 'POST',
+                headers: {
+                    'x-project-id': projectId,
+                },
+                body: JSON.stringify({ query: processedQuery, variables }),
+            });
+            // Fixed: Safe check for errors array
+            if (response.errors && Array.isArray(response.errors) && response.errors.length > 0) {
+                const errorMessages = response.errors.map((e) => e.message).join(', ');
+                throw new MybeSDKError(`GraphQL query failed: ${errorMessages}`, 400, response.errors);
+            }
+            // Convert response keys back to original format (kebab-case if that's what user used)
+            const convertedData = this.convertResponseKeys(response.data, fieldMap);
+            return convertedData;
+        }
+        catch (error) {
+            // Re-throw SDK errors
+            if (error instanceof MybeSDKError) {
+                throw error;
+            }
+            // Handle other errors
+            if (error instanceof Error) {
+                throw new MybeSDKError(`GraphQL request failed: ${error.message}`, undefined, error);
+            }
+            throw new MybeSDKError('GraphQL request failed with unknown error');
+        }
+    }
 }

package/dist/types.d.ts

@@ -17,6 +17,15 @@ export interface ContentType {
     created_at: string;
     updated_at: string;
 }
+/**
+ * Content Type Metadata (for GraphQL responses)
+ */
+export interface ContentTypeMetadata {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+}
 /**
  * Content Entry
  */
@@ -26,6 +35,7 @@ export interface ContentEntry {
     project_id: string;
     slug?: string;
     status: 'draft' | 'published' | 'archived';
+    contentType?: ContentTypeMetadata;
     data: Record<string, any>;
     locale?: string;
     created_by: string;

package/package.json

@@ -1,24 +1,24 @@
-{
-  "name": "@mybe/sdk",
-  "version": "1.0.2",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/",
-    "README.md"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "npm run build && npx tsx test.ts",
-    "prepublishOnly": "npm run build"
-  }
-}
+{
+  "name": "@mybe/sdk",
+  "version": "1.0.5",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && npx tsx test.ts",
+    "prepublishOnly": "npm run build"
+  }
+}