ayezee-astro-cms 1.0.0

package/README.md

@@ -0,0 +1,240 @@
+# @ayezee/astro-cms
+
+AyeZee CMS integration for Astro with automatic data fetching, form handling, and validation.
+
+## Features
+
+- 🚀 **Automatic Data Fetching** - Fetches CMS data during build time
+- 📦 **Type-Safe** - Full TypeScript support with proper types
+- 🔄 **Build-Time Caching** - No runtime API calls needed
+- ✅ **Form Validation** - Client-side and server-side validation support
+- 🔒 **Turnstile Integration** - Built-in Cloudflare Turnstile support
+- 🎨 **Zero Config** - Works with environment variables
+
+## Installation
+
+```bash
+npm install @ayezee/astro-cms
+```
+
+## Quick Start
+
+### 1. Add Environment Variables
+
+Create a `.env` file in your project root:
+
+```env
+PUBLIC_CMS_DOMAIN=http://localhost:3000
+PUBLIC_PROJECT_SLUG=your-project-slug
+PUBLIC_AYEZEE_API_KEY=AZ_your_api_key_here
+```
+
+### 2. Add Integration to Astro Config
+
+```js
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+import { ayezeeCms } from '@ayezee/astro-cms/integration';
+
+export default defineConfig({
+  integrations: [ayezeeCms()],
+});
+```
+
+### 3. Use CMS Data in Your Pages
+
+```astro
+---
+// src/pages/index.astro
+import { initCmsHelper, getModuleData } from '@ayezee/astro-cms';
+import cmsData from '../data/cms-cache.json';
+
+// Initialize the helper (only needed once)
+initCmsHelper(cmsData);
+
+// Get your data
+const testimonials = getModuleData('testimonials');
+---
+
+<div>
+  {testimonials.map((item) => (
+    <div>
+      <h3>{item.data.name}</h3>
+      <p>{item.data.message}</p>
+    </div>
+  ))}
+</div>
+```
+
+## API Reference
+
+### Integration Options
+
+```ts
+ayezeeCms({
+  // CMS domain (defaults to PUBLIC_CMS_DOMAIN env var)
+  cmsDomain?: string;
+
+  // Project slug (defaults to PUBLIC_PROJECT_SLUG env var)
+  projectSlug?: string;
+
+  // Output directory for cache (defaults to 'src/data')
+  outputDir?: string;
+
+  // Cache file name (defaults to 'cms-cache.json')
+  cacheFileName?: string;
+
+  // Skip build if fetch fails (defaults to false)
+  skipOnError?: boolean;
+});
+```
+
+### Helper Functions
+
+#### Module Retrieval
+
+```ts
+import {
+  getModule,
+  getModuleByLabel,
+  getModuleBySlug,
+  getModules,
+  getModulesByCategory,
+  getModulesByDataType,
+} from '@ayezee/astro-cms';
+
+// Get by instance key
+const module = getModule('contact_form-123');
+
+// Get by label (case-insensitive)
+const module = getModuleByLabel('Contact Form');
+
+// Get by slug
+const module = getModuleBySlug('contact-form');
+
+// Get all modules
+const allModules = getModules();
+
+// Get by category
+const formModules = getModulesByCategory('forms');
+
+// Get by type
+const collections = getModulesByDataType('collection');
+```
+
+#### Data Retrieval
+
+```ts
+import {
+  getModuleData,
+  getModuleDataByLabel,
+  getModuleDataBySlug,
+} from '@ayezee/astro-cms';
+
+// Get data by instance key
+const data = getModuleData('testimonials-123');
+
+// Get data by label
+const data = getModuleDataByLabel('Testimonials');
+
+// Get data by slug
+const data = getModuleDataBySlug('testimonials');
+```
+
+#### Form Configuration
+
+```ts
+import { getFormConfig, getTurnstileConfig } from '@ayezee/astro-cms';
+
+// Get complete form configuration
+const config = getFormConfig('Contact Form');
+// Returns: { module, turnstile, apiUrl, apiKey }
+
+// Get just Turnstile config
+const turnstile = getTurnstileConfig('Contact Form');
+// Returns: { enabled: boolean, siteKey: string | null }
+```
+
+#### Project & Cache Info
+
+```ts
+import { getProject, getCacheInfo } from '@ayezee/astro-cms';
+
+// Get project details
+const project = getProject();
+// Returns: { id, slug, name, domain }
+
+// Get cache metadata
+const info = getCacheInfo();
+// Returns: { fetchedAt, version, moduleCount }
+```
+
+## TypeScript Support
+
+The package exports all necessary types:
+
+```ts
+import type {
+  CachedModule,
+  ModuleField,
+  ModuleDataItem,
+  ValidationRules,
+  CMSCache,
+} from '@ayezee/astro-cms';
+```
+
+## Advanced Usage
+
+### Custom Cache Location
+
+```js
+// astro.config.mjs
+export default defineConfig({
+  integrations: [
+    ayezeeCms({
+      outputDir: 'src/custom/location',
+      cacheFileName: 'my-cache.json',
+    }),
+  ],
+});
+```
+
+### Skip Build on Error
+
+Useful for CI/CD when CMS might be temporarily unavailable:
+
+```js
+export default defineConfig({
+  integrations: [
+    ayezeeCms({
+      skipOnError: process.env.NODE_ENV === 'development',
+    }),
+  ],
+});
+```
+
+### Runtime Configuration
+
+Override environment variables programmatically:
+
+```js
+export default defineConfig({
+  integrations: [
+    ayezeeCms({
+      cmsDomain: 'https://cms.example.com',
+      projectSlug: 'my-project',
+    }),
+  ],
+});
+```
+
+## How It Works
+
+1. **Build Time**: The integration fetches all CMS data during `astro build` or `astro dev`
+2. **Caching**: Data is saved to `src/data/cms-cache.json`
+3. **Runtime**: Helper functions read from the cached file (no API calls!)
+4. **Type Safety**: Full TypeScript support with generated types
+
+## License
+
+MIT © AyeZee Web Designs

package/dist/cms-helper.d.ts

@@ -0,0 +1,176 @@
+/**
+ * AyeZee CMS Helper - Build-Time Cached Version
+ *
+ * Provides utilities to access CMS data from the generated cache file
+ *
+ * @example
+ * ```ts
+ * import { getModule, getModuleData } from '@ayezee/astro-cms';
+ *
+ * const testimonials = getModuleData('testimonials');
+ * const contactForm = getModule('contact-form');
+ * ```
+ */
+export interface ModuleField {
+    key: string;
+    label: string;
+    fieldType: string;
+    required?: boolean;
+    options?: unknown[];
+    validation?: ValidationRules;
+    isPreviewField?: boolean;
+    placeholder?: string;
+}
+export interface ValidationRules {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    maxSize?: string;
+    allowedFormats?: string[];
+    options?: string[];
+    schema?: Record<string, unknown>;
+}
+export interface ModuleDataItem {
+    id: string;
+    data: Record<string, unknown>;
+    sortOrder?: number;
+    status?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface CachedModule {
+    id: string;
+    instanceKey: string;
+    label: string;
+    slug: string;
+    dataType: 'collection' | 'singleton' | 'submissions';
+    category: string;
+    description?: string;
+    icon?: string;
+    fields: ModuleField[];
+    isActive: boolean;
+    sortOrder: number;
+    data: ModuleDataItem[];
+    pagination: {
+        total: number;
+        limit?: number | null;
+        offset?: number;
+        count: number;
+    };
+    parameters: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CMSCache {
+    project: {
+        id: string;
+        slug: string;
+        name: string;
+        domain?: string;
+    };
+    modules: CachedModule[];
+    fetchedAt: string;
+    version: string;
+}
+/**
+ * Initialize the CMS helper with cache data
+ * This should be called once at the start of your app
+ */
+export declare function initCmsHelper(cacheData: CMSCache): void;
+/**
+ * Get project information
+ */
+export declare function getProject(): {
+    id: string;
+    slug: string;
+    name: string;
+    domain?: string;
+};
+/**
+ * Get all modules
+ */
+export declare function getModules(): CachedModule[];
+/**
+ * Get a module by its instance key
+ */
+export declare function getModule(instanceKey: string): CachedModule | null;
+/**
+ * Get a module by its label (case-insensitive)
+ */
+export declare function getModuleByLabel(label: string): CachedModule | null;
+/**
+ * Get a module by its slug
+ */
+export declare function getModuleBySlug(slug: string): CachedModule | null;
+/**
+ * Get modules by category
+ */
+export declare function getModulesByCategory(category: string): CachedModule[];
+/**
+ * Get modules by data type
+ */
+export declare function getModulesByDataType(dataType: 'collection' | 'singleton' | 'submissions'): CachedModule[];
+/**
+ * Get all form modules (submissions type)
+ */
+export declare function getForms(): CachedModule[];
+/**
+ * Get all content collections
+ */
+export declare function getCollections(): CachedModule[];
+/**
+ * Get all singleton content
+ */
+export declare function getSingletons(): CachedModule[];
+/**
+ * Get data from a module by instance key
+ */
+export declare function getModuleData(instanceKey: string): ModuleDataItem[];
+/**
+ * Get data from a module by label
+ */
+export declare function getModuleDataByLabel(label: string): ModuleDataItem[];
+/**
+ * Get data from a module by slug
+ */
+export declare function getModuleDataBySlug(slug: string): ModuleDataItem[];
+/**
+ * Get Turnstile configuration for a form module
+ */
+export declare function getTurnstileConfig(moduleIdentifier: string): {
+    enabled: boolean;
+    siteKey: string | null;
+};
+/**
+ * Check if a form has Turnstile enabled
+ */
+export declare function isTurnstileEnabled(moduleIdentifier: string): boolean;
+/**
+ * Get form configuration including all settings
+ */
+export declare function getFormConfig(moduleIdentifier: string, options?: {
+    apiKey?: string;
+    cmsDomain?: string;
+    projectSlug?: string;
+}): {
+    module: CachedModule | null;
+    turnstile: {
+        enabled: boolean;
+        siteKey: string | null;
+    };
+    apiUrl: string;
+    apiKey: string;
+};
+/**
+ * Get metadata about when the cache was last updated
+ */
+export declare function getCacheInfo(): {
+    fetchedAt: string;
+    version: string;
+    moduleCount: number;
+};

package/dist/cms-helper.js

@@ -0,0 +1,190 @@
+/**
+ * AyeZee CMS Helper - Build-Time Cached Version
+ *
+ * Provides utilities to access CMS data from the generated cache file
+ *
+ * @example
+ * ```ts
+ * import { getModule, getModuleData } from '@ayezee/astro-cms';
+ *
+ * const testimonials = getModuleData('testimonials');
+ * const contactForm = getModule('contact-form');
+ * ```
+ */
+// Import cache data - will be resolved by the consuming project
+let cache = null;
+/**
+ * Initialize the CMS helper with cache data
+ * This should be called once at the start of your app
+ */
+export function initCmsHelper(cacheData) {
+    cache = cacheData;
+}
+/**
+ * Get the cache instance (throws if not initialized)
+ */
+function getCache() {
+    if (!cache) {
+        throw new Error('CMS Helper not initialized. Call initCmsHelper() first or import cache data directly.');
+    }
+    return cache;
+}
+/**
+ * Get project information
+ */
+export function getProject() {
+    return getCache().project;
+}
+/**
+ * Get all modules
+ */
+export function getModules() {
+    return getCache().modules;
+}
+/**
+ * Get a module by its instance key
+ */
+export function getModule(instanceKey) {
+    return getCache().modules.find((mod) => mod.instanceKey === instanceKey) || null;
+}
+/**
+ * Get a module by its label (case-insensitive)
+ */
+export function getModuleByLabel(label) {
+    const normalizedLabel = label.toLowerCase();
+    return (getCache().modules.find((mod) => mod.label.toLowerCase() === normalizedLabel) ||
+        null);
+}
+/**
+ * Get a module by its slug
+ */
+export function getModuleBySlug(slug) {
+    return getCache().modules.find((mod) => mod.slug === slug) || null;
+}
+/**
+ * Get modules by category
+ */
+export function getModulesByCategory(category) {
+    return getCache().modules.filter((mod) => mod.category === category);
+}
+/**
+ * Get modules by data type
+ */
+export function getModulesByDataType(dataType) {
+    return getCache().modules.filter((mod) => mod.dataType === dataType);
+}
+/**
+ * Get all form modules (submissions type)
+ */
+export function getForms() {
+    return getModulesByDataType('submissions');
+}
+/**
+ * Get all content collections
+ */
+export function getCollections() {
+    return getModulesByDataType('collection');
+}
+/**
+ * Get all singleton content
+ */
+export function getSingletons() {
+    return getModulesByDataType('singleton');
+}
+/**
+ * Get data from a module by instance key
+ */
+export function getModuleData(instanceKey) {
+    const foundModule = getModule(instanceKey);
+    return foundModule?.data || [];
+}
+/**
+ * Get data from a module by label
+ */
+export function getModuleDataByLabel(label) {
+    const foundModule = getModuleByLabel(label);
+    return foundModule?.data || [];
+}
+/**
+ * Get data from a module by slug
+ */
+export function getModuleDataBySlug(slug) {
+    const foundModule = getModuleBySlug(slug);
+    return foundModule?.data || [];
+}
+/**
+ * Get Turnstile configuration for a form module
+ */
+export function getTurnstileConfig(moduleIdentifier) {
+    // Try to find module by instance key, label, or slug
+    let module = getModule(moduleIdentifier);
+    if (!module) {
+        module = getModuleByLabel(moduleIdentifier);
+    }
+    if (!module) {
+        module = getModuleBySlug(moduleIdentifier);
+    }
+    if (!module || !module.parameters?.turnstile) {
+        return { enabled: false, siteKey: null };
+    }
+    const turnstile = module.parameters.turnstile;
+    return {
+        enabled: turnstile.enabled === true,
+        siteKey: turnstile.siteKey || null,
+    };
+}
+/**
+ * Check if a form has Turnstile enabled
+ */
+export function isTurnstileEnabled(moduleIdentifier) {
+    const config = getTurnstileConfig(moduleIdentifier);
+    return config.enabled && config.siteKey !== null;
+}
+/**
+ * Get form configuration including all settings
+ */
+export function getFormConfig(moduleIdentifier, options) {
+    // Try to find module by instance key, label, or slug
+    let module = getModule(moduleIdentifier);
+    if (!module) {
+        module = getModuleByLabel(moduleIdentifier);
+    }
+    if (!module) {
+        module = getModuleBySlug(moduleIdentifier);
+    }
+    // Get configuration from options or environment variables
+    const cmsDomain = options?.cmsDomain ||
+        (typeof import.meta !== 'undefined' && import.meta.env?.PUBLIC_CMS_DOMAIN) ||
+        'http://localhost:3000';
+    const projectSlug = options?.projectSlug ||
+        (typeof import.meta !== 'undefined' && import.meta.env?.PUBLIC_PROJECT_SLUG) ||
+        '';
+    const apiKey = options?.apiKey ||
+        (typeof import.meta !== 'undefined' && import.meta.env?.PUBLIC_AYEZEE_API_KEY) ||
+        '';
+    let domain = cmsDomain;
+    if (!domain.startsWith('http://') && !domain.startsWith('https://')) {
+        const protocol = domain.includes('localhost') ? 'http' : 'https';
+        domain = `${protocol}://${domain}`;
+    }
+    const apiUrl = module
+        ? `${domain}/api/v1/projects/${projectSlug}/submit/${module.instanceKey}`
+        : '';
+    return {
+        module,
+        turnstile: getTurnstileConfig(moduleIdentifier),
+        apiUrl,
+        apiKey,
+    };
+}
+/**
+ * Get metadata about when the cache was last updated
+ */
+export function getCacheInfo() {
+    return {
+        fetchedAt: getCache().fetchedAt,
+        version: getCache().version,
+        moduleCount: getCache().modules.length,
+    };
+}
+// Types are already exported above, no need to re-export

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AyeZee CMS Astro Integration
+ *
+ * Provides automatic CMS data fetching and helper utilities for Astro projects
+ *
+ * @packageDocumentation
+ */
+export * from './cms-helper.js';
+export { ayezeeCms, type AyezeeCmsOptions } from './integration.js';
+export { ayezeeCms as default } from './integration.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * AyeZee CMS Astro Integration
+ *
+ * Provides automatic CMS data fetching and helper utilities for Astro projects
+ *
+ * @packageDocumentation
+ */
+// Export CMS helper functions and types
+export * from './cms-helper.js';
+// Export integration
+export { ayezeeCms } from './integration.js';
+// Default export
+export { ayezeeCms as default } from './integration.js';

package/dist/integration.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AyeZee CMS Astro Integration
+ *
+ * Automatically fetches CMS data during Astro build process
+ *
+ * @example
+ * ```js
+ * // astro.config.mjs
+ * import { ayezeeCms } from '@ayezee/astro-cms/integration';
+ *
+ * export default defineConfig({
+ *   integrations: [ayezeeCms()]
+ * });
+ * ```
+ */
+import type { AstroIntegration } from 'astro';
+export interface AyezeeCmsOptions {
+    /**
+     * CMS domain URL
+     * @default process.env.PUBLIC_CMS_DOMAIN
+     */
+    cmsDomain?: string;
+    /**
+     * Project slug identifier
+     * @default process.env.PUBLIC_PROJECT_SLUG
+     */
+    projectSlug?: string;
+    /**
+     * Output directory for cached data
+     * @default 'src/data'
+     */
+    outputDir?: string;
+    /**
+     * Cache file name
+     * @default 'cms-cache.json'
+     */
+    cacheFileName?: string;
+    /**
+     * Skip build if fetch fails
+     * @default false
+     */
+    skipOnError?: boolean;
+}
+/**
+ * AyeZee CMS Astro Integration
+ */
+export declare function ayezeeCms(options?: AyezeeCmsOptions): AstroIntegration;
+export default ayezeeCms;

package/dist/integration.js

@@ -0,0 +1,167 @@
+/**
+ * AyeZee CMS Astro Integration
+ *
+ * Automatically fetches CMS data during Astro build process
+ *
+ * @example
+ * ```js
+ * // astro.config.mjs
+ * import { ayezeeCms } from '@ayezee/astro-cms/integration';
+ *
+ * export default defineConfig({
+ *   integrations: [ayezeeCms()]
+ * });
+ * ```
+ */
+import fs from 'fs';
+import path from 'path';
+/**
+ * Load environment variables from .env file
+ */
+function loadEnvFile() {
+    const envPath = path.join(process.cwd(), '.env');
+    if (fs.existsSync(envPath)) {
+        const envContent = fs.readFileSync(envPath, 'utf-8');
+        const lines = envContent.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const match = trimmed.match(/^([^=]+)=(.*)$/);
+            if (match) {
+                const key = match[1].trim();
+                const value = match[2].trim().replace(/^["']|["']$/g, '');
+                if (!process.env[key]) {
+                    process.env[key] = value;
+                }
+            }
+        }
+    }
+}
+/**
+ * Convert text to URL-friendly slug
+ */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * AyeZee CMS Astro Integration
+ */
+export function ayezeeCms(options = {}) {
+    return {
+        name: 'ayezee-cms',
+        hooks: {
+            'astro:config:setup': async ({ config, logger }) => {
+                logger.info('🚀 AyeZee CMS: Fetching data...');
+                // Load environment variables from .env
+                loadEnvFile();
+                // Get configuration
+                const cmsDomain = options.cmsDomain || process.env.PUBLIC_CMS_DOMAIN;
+                const projectSlug = options.projectSlug || process.env.PUBLIC_PROJECT_SLUG;
+                const outputDir = options.outputDir || 'src/data';
+                const cacheFileName = options.cacheFileName || 'cms-cache.json';
+                const skipOnError = options.skipOnError || false;
+                // Validate config
+                if (!cmsDomain || !projectSlug) {
+                    const errorMsg = 'Missing environment variables:';
+                    if (!cmsDomain)
+                        logger.error(`   - PUBLIC_CMS_DOMAIN`);
+                    if (!projectSlug)
+                        logger.error(`   - PUBLIC_PROJECT_SLUG`);
+                    if (skipOnError) {
+                        logger.warn('⚠️  Skipping CMS data fetch due to missing config');
+                        return;
+                    }
+                    throw new Error(`AyeZee CMS integration requires PUBLIC_CMS_DOMAIN and PUBLIC_PROJECT_SLUG`);
+                }
+                logger.info(`   Domain: ${cmsDomain}`);
+                logger.info(`   Project: ${projectSlug}`);
+                try {
+                    // Build API URL
+                    let domain = cmsDomain;
+                    if (!domain.startsWith('http://') && !domain.startsWith('https://')) {
+                        const protocol = domain.includes('localhost') ? 'http' : 'https';
+                        domain = `${protocol}://${domain}`;
+                    }
+                    const baseUrl = `${domain}/api/v1/projects/${projectSlug}`;
+                    // Fetch modules
+                    logger.info('📡 Fetching modules...');
+                    const modulesResponse = await fetch(`${baseUrl}/modules`);
+                    if (!modulesResponse.ok) {
+                        throw new Error(`API error: ${modulesResponse.status} ${modulesResponse.statusText}`);
+                    }
+                    const modulesResult = await modulesResponse.json();
+                    if (!modulesResult.success) {
+                        throw new Error(modulesResult.message || 'Failed to fetch modules');
+                    }
+                    const modules = modulesResult.data.modules;
+                    logger.info(`✅ Found ${modules.length} modules`);
+                    // Fetch data for each module
+                    const modulesWithData = [];
+                    for (const module of modules) {
+                        try {
+                            const dataResponse = await fetch(`${baseUrl}/modules/${module.instanceKey}/data`);
+                            const dataResult = await dataResponse.json();
+                            const itemCount = dataResult.data?.pagination?.total || 0;
+                            logger.info(`   📦 ${module.label}: ${itemCount} items`);
+                            modulesWithData.push({
+                                ...module,
+                                slug: slugify(module.label),
+                                data: dataResult.data?.data || [],
+                                pagination: dataResult.data?.pagination || {
+                                    total: 0,
+                                    count: 0,
+                                },
+                                parameters: dataResult.data?.module?.parameters || {},
+                            });
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                            logger.warn(`   ⚠️  Failed to fetch ${module.label}: ${errorMessage}`);
+                            modulesWithData.push({
+                                ...module,
+                                slug: slugify(module.label),
+                                data: [],
+                                pagination: { total: 0, count: 0 },
+                                parameters: {},
+                            });
+                        }
+                    }
+                    // Create cache data
+                    const cacheData = {
+                        project: modulesResult.data.project,
+                        modules: modulesWithData,
+                        fetchedAt: new Date().toISOString(),
+                        version: '1.0',
+                    };
+                    // Get the data directory path
+                    const dataDir = path.join(process.cwd(), outputDir);
+                    // Ensure directory exists
+                    if (!fs.existsSync(dataDir)) {
+                        fs.mkdirSync(dataDir, { recursive: true });
+                    }
+                    // Write cache file
+                    const cachePath = path.join(dataDir, cacheFileName);
+                    fs.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), 'utf-8');
+                    logger.info(`✅ Cached data to: ${path.relative(process.cwd(), cachePath)}`);
+                    logger.info(`📅 Fetched at: ${cacheData.fetchedAt}`);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    logger.error('❌ Failed to fetch CMS data:');
+                    logger.error(`   ${errorMessage}`);
+                    if (skipOnError) {
+                        logger.warn('⚠️  Continuing build without CMS data');
+                        return;
+                    }
+                    throw error;
+                }
+            },
+        },
+    };
+}
+export default ayezeeCms;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "ayezee-astro-cms",
+  "version": "1.0.0",
+  "description": "AyeZee CMS integration for Astro with automatic data fetching, form handling, and validation",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.ts",
+      "import": "./dist/integration.js"
+    },
+    "./components": {
+      "types": "./dist/components/index.d.ts",
+      "import": "./dist/components/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "astro",
+    "cms",
+    "ayezee",
+    "integration",
+    "form",
+    "validation"
+  ],
+  "author": "AyeZee Web Designs",
+  "license": "MIT",
+  "peerDependencies": {
+    "astro": "^4.0.0 || ^5.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ayezeewebdesigns/astro-cms.git"
+  }
+}