@mybe/sdk 1.0.0 → 1.0.2

package/README.md

@@ -50,7 +50,9 @@ const sdk = new MybeSDK({
 
 The SDK automatically detects the environment:
 - **Development** (`NODE_ENV=development`): Uses `http://localhost:3001/api/v1`
-- **Production**: Uses `https://api.mybe.app/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)
 

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+import { MybeSDKConfig, ContentType, ContentEntry, ContentFilterOptions, ContentListResponse } from './types.js';
+export declare class MybeSDK {
+    private apiKey;
+    private baseUrl;
+    constructor(config: MybeSDKConfig);
+    /**
+     * Make HTTP request to API
+     */
+    private request;
+    /**
+     * Build query string from options
+     */
+    private buildQueryString;
+    /**
+     * Get all content models (content types) for a project
+     */
+    getContentModels(projectId: string): Promise<ContentType[]>;
+    /**
+     * Get a specific content model by ID
+     */
+    getContentModel(contentTypeId: string): Promise<ContentType>;
+    /**
+     * Get a single content entry by ID
+     */
+    getContent(contentId: string): Promise<ContentEntry>;
+    /**
+     * Get all content entries for a specific content type
+     */
+    getContentByType(contentTypeId: string, options?: ContentFilterOptions): Promise<ContentListResponse>;
+    /**
+     * Get all content entries for a project
+     */
+    getContentByProject(projectId: string, options?: ContentFilterOptions): Promise<ContentListResponse>;
+}

package/dist/client.js

@@ -0,0 +1,129 @@
+import { MybeSDKError, NotFoundError, UnauthorizedError, ValidationError, ServerError, ForbiddenError, } from './errors.js';
+export class MybeSDK {
+    apiKey;
+    baseUrl;
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new MybeSDKError('API key is required');
+        }
+        this.apiKey = config.apiKey;
+        if (config.baseUrl) {
+            this.baseUrl = config.baseUrl;
+        }
+        else {
+            const isDevelopment = typeof process !== 'undefined' &&
+                process.env.NODE_ENV === 'development';
+            // Use REST API endpoint for production (with API key validation and usage tracking)
+            this.baseUrl = isDevelopment
+                ? 'http://localhost:3001/api/v1'
+                : 'https://fizsdck7l0.execute-api.us-east-1.amazonaws.com/dev/api/v1';
+        }
+    }
+    /**
+     * Make HTTP request to API
+     */
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-API-Key': this.apiKey,
+            ...options.headers,
+        };
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers,
+            });
+            const data = await response.json();
+            // Handle error responses
+            if (!response.ok) {
+                const errorMessage = data.message || 'An error occurred';
+                switch (response.status) {
+                    case 400:
+                        throw new ValidationError(errorMessage, data);
+                    case 401:
+                        throw new UnauthorizedError(errorMessage, data);
+                    case 403:
+                        throw new ForbiddenError(errorMessage, data);
+                    case 404:
+                        throw new NotFoundError(errorMessage, data);
+                    case 500:
+                    case 502:
+                    case 503:
+                        throw new ServerError(errorMessage, data);
+                    default:
+                        throw new MybeSDKError(errorMessage, response.status, data);
+                }
+            }
+            return data;
+        }
+        catch (error) {
+            // Re-throw SDK errors
+            if (error instanceof MybeSDKError) {
+                throw error;
+            }
+            // Handle network errors
+            if (error instanceof Error) {
+                throw new MybeSDKError(`Network error: ${error.message}`, undefined, error);
+            }
+            throw new MybeSDKError('An unknown error occurred');
+        }
+    }
+    /**
+     * Build query string from options
+     */
+    buildQueryString(options) {
+        if (!options)
+            return '';
+        const params = new URLSearchParams();
+        if (options.status) {
+            params.append('status', options.status);
+        }
+        if (options.locale) {
+            params.append('locale', options.locale);
+        }
+        if (options.limit) {
+            params.append('limit', options.limit.toString());
+        }
+        if (options.lastKey) {
+            params.append('lastKey', encodeURIComponent(options.lastKey));
+        }
+        const queryString = params.toString();
+        return queryString ? `?${queryString}` : '';
+    }
+    /**
+     * Get all content models (content types) for a project
+     */
+    async getContentModels(projectId) {
+        const response = await this.request(`/content-models/${projectId}`);
+        return response.data;
+    }
+    /**
+     * Get a specific content model by ID
+     */
+    async getContentModel(contentTypeId) {
+        const response = await this.request(`/content-model/${contentTypeId}`);
+        return response.data;
+    }
+    /**
+     * Get a single content entry by ID
+     */
+    async getContent(contentId) {
+        const response = await this.request(`/content-entry/${contentId}`);
+        return response.data;
+    }
+    /**
+     * Get all content entries for a specific content type
+     */
+    async getContentByType(contentTypeId, options) {
+        const queryString = this.buildQueryString(options);
+        return await this.request(`/type/${contentTypeId}${queryString}`);
+    }
+    /**
+     * Get all content entries for a project
+     */
+    async getContentByProject(projectId, options) {
+        const queryString = this.buildQueryString(options);
+        return await this.request(`/content-entry/project/${projectId}${queryString}`);
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Base SDK Error
+ */
+export declare class MybeSDKError extends Error {
+    statusCode?: number;
+    response?: any;
+    constructor(message: string, statusCode?: number, response?: any);
+}
+/**
+ * Not Found Error (404)
+ */
+export declare class NotFoundError extends MybeSDKError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Unauthorized Error (401)
+ */
+export declare class UnauthorizedError extends MybeSDKError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Validation Error (400)
+ */
+export declare class ValidationError extends MybeSDKError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Server Error (500)
+ */
+export declare class ServerError extends MybeSDKError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Forbidden Error (403)
+ */
+export declare class ForbiddenError extends MybeSDKError {
+    constructor(message?: string, response?: any);
+}

package/dist/errors.js

@@ -0,0 +1,64 @@
+/**
+ * Base SDK Error
+ */
+export class MybeSDKError extends Error {
+    statusCode;
+    response;
+    constructor(message, statusCode, response) {
+        super(message);
+        this.name = 'MybeSDKError';
+        this.statusCode = statusCode;
+        this.response = response;
+        Object.setPrototypeOf(this, MybeSDKError.prototype);
+    }
+}
+/**
+ * Not Found Error (404)
+ */
+export class NotFoundError extends MybeSDKError {
+    constructor(message = 'Resource not found', response) {
+        super(message, 404, response);
+        this.name = 'NotFoundError';
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+/**
+ * Unauthorized Error (401)
+ */
+export class UnauthorizedError extends MybeSDKError {
+    constructor(message = 'Unauthorized - Invalid API key', response) {
+        super(message, 401, response);
+        this.name = 'UnauthorizedError';
+        Object.setPrototypeOf(this, UnauthorizedError.prototype);
+    }
+}
+/**
+ * Validation Error (400)
+ */
+export class ValidationError extends MybeSDKError {
+    constructor(message = 'Validation failed', response) {
+        super(message, 400, response);
+        this.name = 'ValidationError';
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+/**
+ * Server Error (500)
+ */
+export class ServerError extends MybeSDKError {
+    constructor(message = 'Internal server error', response) {
+        super(message, 500, response);
+        this.name = 'ServerError';
+        Object.setPrototypeOf(this, ServerError.prototype);
+    }
+}
+/**
+ * Forbidden Error (403)
+ */
+export class ForbiddenError extends MybeSDKError {
+    constructor(message = 'Forbidden - Insufficient permissions', response) {
+        super(message, 403, response);
+        this.name = 'ForbiddenError';
+        Object.setPrototypeOf(this, ForbiddenError.prototype);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Mybe CMS SDK
+ *
+ * A TypeScript SDK for fetching content from Mybe CMS.
+ *
+ * @example
+ * ```typescript
+ * import { MybeSDK } from '@mybe/sdk';
+ *
+ * const sdk = new MybeSDK({
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Fetch content
+ * const content = await sdk.getContent('content-id');
+ * const contentList = await sdk.getContentByType('content-type-id', {
+ *   status: 'published',
+ *   limit: 10
+ * });
+ * ```
+ */
+export { MybeSDK } from './client.js';
+export { MybeSDKConfig, ContentType, ContentEntry, ContentFilterOptions, PaginationOptions, PaginationResponse, APIResponse, ContentListResponse, } from './types.js';
+export { MybeSDKError, NotFoundError, UnauthorizedError, ValidationError, ServerError, ForbiddenError, } from './errors.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * Mybe CMS SDK
+ *
+ * A TypeScript SDK for fetching content from Mybe CMS.
+ *
+ * @example
+ * ```typescript
+ * import { MybeSDK } from '@mybe/sdk';
+ *
+ * const sdk = new MybeSDK({
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Fetch content
+ * const content = await sdk.getContent('content-id');
+ * const contentList = await sdk.getContentByType('content-type-id', {
+ *   status: 'published',
+ *   limit: 10
+ * });
+ * ```
+ */
+export { MybeSDK } from './client.js';
+export { MybeSDKError, NotFoundError, UnauthorizedError, ValidationError, ServerError, ForbiddenError, } from './errors.js';

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * SDK Configuration
+ */
+export interface MybeSDKConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+/**
+ * Content Type (Content Model)
+ */
+export interface ContentType {
+    id: string;
+    project_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Content Entry
+ */
+export 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;
+}
+/**
+ * Pagination Options
+ */
+export interface PaginationOptions {
+    limit?: number;
+    lastKey?: string;
+}
+/**
+ * Content Filter Options
+ */
+export interface ContentFilterOptions extends PaginationOptions {
+    status?: 'draft' | 'published' | 'archived';
+    locale?: string;
+}
+/**
+ * Pagination Response
+ */
+export interface PaginationResponse {
+    lastEvaluatedKey?: Record<string, any>;
+    hasMore: boolean;
+}
+/**
+ * API Response Wrapper
+ */
+export interface APIResponse<T> {
+    data: T;
+    message: string;
+    pagination?: PaginationResponse;
+}
+/**
+ * Content List Response
+ */
+export interface ContentListResponse {
+    data: ContentEntry[];
+    pagination: PaginationResponse;
+    message: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@mybe/sdk",
-  "version": "1.0.0",
+  "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",
@@ -15,11 +19,6 @@
     "dev": "tsc --watch",
     "typecheck": "tsc --noEmit",
     "test": "npm run build && npx tsx test.ts",
-    "prepublishOnly": "npm run build",
-    "prepack": "npm run build"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "typescript": "^5.9.2"
+    "prepublishOnly": "npm run build"
   }
 }