@kyro-cms/core 0.1.0

package/README.md

@@ -0,0 +1,241 @@
+# Kyro CMS
+
+**Astro-Native Headless CMS with Multi-Database Adapters, Multi-Protocol APIs, and Multi-Vendor Support**
+
+Kyro is an open-source, TypeScript-native headless CMS inspired by Payload CMS but architected specifically for Astro JS. It provides zero-inference tRPC, SQL-sovereign Drizzle schemas, and built-in multi-tenancy.
+
+---
+
+## Features
+
+### Local-First with SQLite
+```typescript
+import { createKyro, LocalAdapter } from '@kyro-cms/core';
+
+const kyro = createKyro({
+  adapter: new LocalAdapter({ path: './data.db' }),
+  collections: [productsCollection],
+});
+```
+Works out of the box - no external database required.
+
+### Deploy Anywhere with Adapters
+- **Local/SQLite**: Zero-config local development
+- **PostgreSQL/MySQL/SQLite**: Via Drizzle ORM
+- **MongoDB**: NoSQL flexibility
+
+### E-Commerce Ready
+Pre-built collections for:
+- Products with variants, pricing, inventory
+- Customers with addresses, orders
+- Orders with items, shipping, payments
+- Coupons and promotions
+- Inventory tracking
+
+### Multi-Protocol API
+- **REST**: Hono-based with query params
+- **GraphQL**: Dynamic schema
+- **tRPC**: Type-safe RPC (zero inference)
+- **WebSocket**: Real-time pub/sub
+
+### Multi-Vendor Ready
+Row-level access control with tenant scoping built-in.
+
+### Plugin System
+Extend with:
+- SEO (sitemaps, structured data)
+- Analytics
+- Reviews & Comments
+- Wishlists
+
+### Any Styling System
+- Plain CSS
+- Tailwind CSS
+- CSS-in-JS
+- Styled Components
+- Vanilla Extract
+
+---
+
+## Quick Start
+
+```bash
+npm install @kyro-cms/core
+```
+
+### Basic Setup
+
+```typescript
+import { createKyro, LocalAdapter } from '@kyro-cms/core';
+
+const kyro = createKyro({
+  adapter: new LocalAdapter(),
+  collections: [{
+    slug: 'posts',
+    fields: [
+      { name: 'title', type: 'text', required: true },
+      { name: 'content', type: 'richtext' },
+    ],
+  }],
+});
+
+await kyro.init();
+```
+
+### REST API
+
+```bash
+curl http://localhost:3000/api/posts
+curl -X POST http://localhost:3000/api/posts \
+  -H "Content-Type: application/json" \
+  -d '{"title":"Hello World"}'
+```
+
+### GraphQL
+
+```graphql
+query { postsFind { docs { id title } totalDocs } }
+mutation { postsCreate(data: { title: "New Post" }) { doc { id } } }
+```
+
+---
+
+## E-Commerce Example
+
+```typescript
+import { createKyro, LocalAdapter } from '@kyro-cms/core';
+import { 
+  productsCollection, 
+  ordersCollection, 
+  customersCollection,
+  ecommerceCollections 
+} from '@kyro-cms/core/examples/ecommerce';
+
+const kyro = createKyro({
+  adapter: new LocalAdapter({ path: './store.db' }),
+  collections: ecommerceCollections,
+  tenantScoped: true, // Multi-vendor
+});
+
+await kyro.init();
+```
+
+---
+
+## Plugin System
+
+```typescript
+import { createKyro, SEOPLugin, ReviewsPlugin } from '@kyro-cms/core';
+
+const kyro = createKyro({
+  adapter: new LocalAdapter(),
+  collections: [...],
+  plugins: [
+    new SEOPLugin(),
+    new ReviewsPlugin(),
+  ],
+});
+```
+
+---
+
+## Styling
+
+```typescript
+import { ecommerce2026Theme, generateCSSVariables } from '@kyro-cms/core';
+
+// Generate CSS variables
+const css = generateCSSVariables(ecommerce2026Theme);
+```
+
+---
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                        Your Config                          │
+│              (CollectionConfig[])                           │
+└───────────────────────────┬──────────────────────────────────┘
+                          │
+                          ▼
+┌──────────────────────────────────────────────────────────────┐
+│  Registry                                                     │
+│  • Stores configs                                             │
+│  • Generates Zod schemas                                     │
+│  • Validates config                                          │
+└───────────────────────────┬──────────────────────────────────┘
+                          │
+         ┌────────────────┼────────────────┐
+         ▼                ▼                ▼
+┌─────────────────┐ ┌─────────────┐ ┌─────────────────┐
+│  Local/SQLite   │ │   Drizzle   │ │   MongoDB       │
+│  (Local-first) │ │   (SQL)     │ │   (NoSQL)       │
+└─────────────────┘ └─────────────┘ └─────────────────┘
+                          │
+                          ▼
+┌──────────────────────────────────────────────────────────────┐
+│  Multi-Protocol API Gateway                                  │
+│  • REST (Hono)    • GraphQL    • tRPC    • WebSocket        │
+└──────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Project Structure
+
+```
+kyro-cms/
+├── src/
+│   ├── index.ts              # Main exports
+│   ├── registry/             # Configuration engine
+│   ├── fields/               # 21 field types
+│   ├── database/             # Adapters (Local, Drizzle, MongoDB)
+│   ├── api/                  # REST, GraphQL, tRPC, WebSocket
+│   ├── plugins/              # Plugin system
+│   ├── styling/              # Theming & CSS generation
+│   └── cli/                  # CLI tools
+├── admin/                    # Admin dashboard
+├── examples/
+│   ├── basic.config.ts      # Blog example
+│   └── ecommerce.config.ts   # E-commerce example
+└── docs/                     # Documentation
+```
+
+---
+
+## CLI Commands
+
+```bash
+kyro generate        # Generate TypeScript types
+kyro migrate         # Run migrations
+kyro health          # Check system health
+```
+
+---
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md)
+- [API Reference](docs/api.md)
+- [E-Commerce Guide](docs/ecommerce.md)
+- [Plugin Development](docs/plugins.md)
+- [Styling Guide](docs/styling.md)
+
+---
+
+## License
+
+MIT
+
+---
+
+## Roadmap
+
+- [x] Local-first SQLite adapter
+- [x] E-commerce collections
+- [x] Plugin system
+- [x] Styling abstraction
+- [ ] Full admin dashboard
+- [ ] Authentication
+- [ ] Version history

package/dist/base-CQkFzqQl.d.ts

@@ -0,0 +1,62 @@
+import { B as BaseAdapter, C as CollectionConfig, G as GlobalConfig, a as FindArgs, b as FindResult, c as FindByIDArgs, d as CreateArgs, U as UpdateArgs, D as DeleteArgs, F as Field, R as RelationshipField, e as UploadField } from './types-BGM5MV_K.js';
+
+declare abstract class AbstractBaseAdapter implements BaseAdapter {
+    protected collections: Map<string, CollectionConfig>;
+    protected globals: Map<string, GlobalConfig>;
+    protected connected: boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    init(collections: CollectionConfig[], globals?: GlobalConfig[]): Promise<void>;
+    abstract find<T>(args: FindArgs): Promise<FindResult<T>>;
+    abstract findByID<T>(args: FindByIDArgs): Promise<T | null>;
+    abstract create<T>(args: CreateArgs): Promise<T>;
+    abstract update<T>(args: UpdateArgs): Promise<T>;
+    abstract delete<T>(args: DeleteArgs): Promise<T>;
+    abstract count(args: {
+        collection: string;
+        where?: Record<string, any>;
+        tenantID?: string;
+    }): Promise<number>;
+    abstract findOne(args: {
+        collection: string;
+        where: Record<string, any>;
+        tenantID?: string;
+    }): Promise<any>;
+    abstract findVersions(args: FindArgs): Promise<FindResult<any>>;
+    abstract findVersionByID(args: FindByIDArgs): Promise<any>;
+    abstract createVersion(args: CreateArgs): Promise<any>;
+    abstract deleteVersions(args: {
+        collection: string;
+        where: Record<string, any>;
+    }): Promise<void>;
+    migrate?(): Promise<void>;
+    rollback?(): Promise<void>;
+    transaction?<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    protected getCollection(slug: string): CollectionConfig;
+    protected applyTenantFilter(where?: Record<string, any>, tenantID?: string): Record<string, any>;
+    protected getTableName(slug: string): string;
+    protected prepareData(data: Record<string, any>, collection: CollectionConfig): Record<string, any>;
+    protected processRelationships(data: Record<string, any>, fields: Field[], depth: number): Record<string, any>;
+    protected parseSort(sort?: string): {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    protected calculatePagination(page: number, limit: number, totalDocs: number): {
+        totalDocs: number;
+        limit: number;
+        totalPages: number;
+        page: number;
+        pagingCounter: number;
+        hasPrevPage: boolean;
+        hasNextPage: boolean;
+        prevPage: number | null;
+        nextPage: number | null;
+    };
+    protected selectFields(data: Record<string, any>, select?: string[]): Record<string, any>;
+    protected isRelationshipField(field: Field): field is RelationshipField;
+    protected isUploadField(field: Field): field is UploadField;
+    protected getRelationshipFields(fields: Field[]): RelationshipField[];
+    protected getUploadFields(fields: Field[]): UploadField[];
+}
+
+export { AbstractBaseAdapter as A };

package/dist/base-DlhVlwnN.d.cts

@@ -0,0 +1,62 @@
+import { B as BaseAdapter, C as CollectionConfig, G as GlobalConfig, a as FindArgs, b as FindResult, c as FindByIDArgs, d as CreateArgs, U as UpdateArgs, D as DeleteArgs, F as Field, R as RelationshipField, e as UploadField } from './types-BGM5MV_K.cjs';
+
+declare abstract class AbstractBaseAdapter implements BaseAdapter {
+    protected collections: Map<string, CollectionConfig>;
+    protected globals: Map<string, GlobalConfig>;
+    protected connected: boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    init(collections: CollectionConfig[], globals?: GlobalConfig[]): Promise<void>;
+    abstract find<T>(args: FindArgs): Promise<FindResult<T>>;
+    abstract findByID<T>(args: FindByIDArgs): Promise<T | null>;
+    abstract create<T>(args: CreateArgs): Promise<T>;
+    abstract update<T>(args: UpdateArgs): Promise<T>;
+    abstract delete<T>(args: DeleteArgs): Promise<T>;
+    abstract count(args: {
+        collection: string;
+        where?: Record<string, any>;
+        tenantID?: string;
+    }): Promise<number>;
+    abstract findOne(args: {
+        collection: string;
+        where: Record<string, any>;
+        tenantID?: string;
+    }): Promise<any>;
+    abstract findVersions(args: FindArgs): Promise<FindResult<any>>;
+    abstract findVersionByID(args: FindByIDArgs): Promise<any>;
+    abstract createVersion(args: CreateArgs): Promise<any>;
+    abstract deleteVersions(args: {
+        collection: string;
+        where: Record<string, any>;
+    }): Promise<void>;
+    migrate?(): Promise<void>;
+    rollback?(): Promise<void>;
+    transaction?<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    protected getCollection(slug: string): CollectionConfig;
+    protected applyTenantFilter(where?: Record<string, any>, tenantID?: string): Record<string, any>;
+    protected getTableName(slug: string): string;
+    protected prepareData(data: Record<string, any>, collection: CollectionConfig): Record<string, any>;
+    protected processRelationships(data: Record<string, any>, fields: Field[], depth: number): Record<string, any>;
+    protected parseSort(sort?: string): {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    protected calculatePagination(page: number, limit: number, totalDocs: number): {
+        totalDocs: number;
+        limit: number;
+        totalPages: number;
+        page: number;
+        pagingCounter: number;
+        hasPrevPage: boolean;
+        hasNextPage: boolean;
+        prevPage: number | null;
+        nextPage: number | null;
+    };
+    protected selectFields(data: Record<string, any>, select?: string[]): Record<string, any>;
+    protected isRelationshipField(field: Field): field is RelationshipField;
+    protected isUploadField(field: Field): field is UploadField;
+    protected getRelationshipFields(fields: Field[]): RelationshipField[];
+    protected getUploadFields(fields: Field[]): UploadField[];
+}
+
+export { AbstractBaseAdapter as A };

package/dist/chunk-3Q3FS5J4.cjs

@@ -0,0 +1,273 @@
+'use strict';
+
+var chunkRLTG4YZM_cjs = require('./chunk-RLTG4YZM.cjs');
+
+// src/database/drizzle/adapter.ts
+function fieldToDrizzleType(field, dialect = "postgres") {
+  switch (field.type) {
+    case "text":
+    case "email":
+    case "password":
+    case "textarea":
+    case "color":
+    case "code":
+    case "markdown":
+      return dialect === "sqlite" ? "text" : "varchar";
+    case "number":
+      return field.integer ? "integer" : "decimal";
+    case "checkbox":
+      return "boolean";
+    case "date":
+      return "timestamp";
+    case "select":
+    case "radio":
+      return dialect === "sqlite" ? "text" : "varchar";
+    case "richtext":
+    case "json":
+    case "array":
+    case "group":
+    case "blocks":
+    case "row":
+    case "collapsible":
+    case "tabs":
+      return "jsonb";
+    case "relationship":
+      return dialect === "sqlite" ? "text" : "varchar";
+    case "upload":
+      return dialect === "sqlite" ? "text" : "varchar";
+    default:
+      return "jsonb";
+  }
+}
+function collectionToDrizzleSchema(collection, dialect = "postgres") {
+  const tableName = collection.slug.replace(/-/g, "_");
+  const lines = [];
+  lines.push(`export const ${tableName} = ${dialect === "mysql" ? "mysqlTable" : "pgTable"}('${tableName}', {`);
+  lines.push(`  id: ${dialect === "mysql" ? "varchar" : "uuid"}('${dialect === "mysql" ? "id" : "id"}').${dialect === "mysql" ? "primaryKey().default(sql`UUID()`)" : "primaryKey().defaultRandom()"},`);
+  for (const field of collection.fields) {
+    if (field.name === "id") continue;
+    const dbType = fieldToDrizzleType(field, dialect);
+    const isRequired = field.required;
+    let fieldDef = `  ${field.name}: ${dialect === "mysql" ? "mysql" : "pg"}.${dbType}('${field.name}')`;
+    if (field.unique) fieldDef += ".unique()";
+    if (!isRequired) fieldDef += ".nullable()";
+    if (field.defaultValue !== void 0) {
+      if (typeof field.defaultValue === "string") {
+        fieldDef += `.default('${field.defaultValue}')`;
+      } else if (typeof field.defaultValue === "boolean") {
+        fieldDef += `.default(${field.defaultValue})`;
+      } else {
+        fieldDef += `.default(sql\`${JSON.stringify(field.defaultValue)}\`)`;
+      }
+    }
+    fieldDef += ",";
+    lines.push(fieldDef);
+  }
+  if (collection.timestamps) {
+    lines.push(`  createdAt: ${dialect === "mysql" ? "mysql" : "pg"}.timestamp('created_at').defaultNow(),`);
+    lines.push(`  updatedAt: ${dialect === "mysql" ? "mysql" : "pg"}.timestamp('updated_at').defaultNow(),`);
+  }
+  if (collection.tenantScoped) {
+    lines.push(`  tenantId: ${dialect === "mysql" ? "mysql" : "pg"}.varchar('tenant_id'),`);
+  }
+  lines.push("});");
+  return lines.join("\n");
+}
+var DrizzleAdapter = class extends chunkRLTG4YZM_cjs.AbstractBaseAdapter {
+  client;
+  schema;
+  dialect;
+  constructor(options) {
+    super();
+    this.client = options.client;
+    this.schema = options.schema || {};
+    this.dialect = options.type;
+  }
+  async connect() {
+    this.connected = true;
+    console.log(`[DrizzleAdapter] Connected to ${this.dialect}`);
+  }
+  async disconnect() {
+    this.connected = false;
+    console.log(`[DrizzleAdapter] Disconnected from ${this.dialect}`);
+  }
+  async find(args) {
+    const { collection: slug, where = {}, sort, limit = 10, page = 1, tenantID, select } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    const filters = this.buildWhereClause(where, config, tenantID);
+    const sortOption = this.parseSort(sort);
+    const totalDocs = await this.count({ collection: slug, where, tenantID });
+    const offset = (page - 1) * limit;
+    let docs = [];
+    try {
+      const results = await this.client.select().from(table).where(filters).orderBy(sortOption.direction === "asc" ? table[sortOption.field] : void 0).limit(limit).offset(offset);
+      docs = results.map((doc) => this.processResult(doc, config));
+    } catch (error) {
+      console.error(`[DrizzleAdapter] Query error:`, error);
+      docs = [];
+    }
+    return {
+      docs,
+      ...this.calculatePagination(page, limit, totalDocs)
+    };
+  }
+  async findByID(args) {
+    const { collection: slug, id, tenantID } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    let query = this.client.select().from(table).where(table.id.equals(id));
+    if (tenantID) {
+      query = query.where(table.tenantId.equals(tenantID));
+    }
+    const results = await query.limit(1);
+    if (results.length === 0) return null;
+    return this.processResult(results[0], config);
+  }
+  async create(args) {
+    const { collection: slug, data, tenantID } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    const insertData = this.prepareData(data, config);
+    if (tenantID) {
+      insertData.tenantId = tenantID;
+    }
+    const result = await this.client.insert(table).values(insertData).returning();
+    return this.processResult(result[0], config);
+  }
+  async update(args) {
+    const { collection: slug, id, data, tenantID } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    const updateData = this.prepareData(data, config);
+    if (tenantID) {
+      updateData.tenantId = tenantID;
+    }
+    const result = await this.client.update(table).set(updateData).where(table.id.equals(id)).returning();
+    return this.processResult(result[0], config);
+  }
+  async delete(args) {
+    const { collection: slug, id, tenantID } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    let query = this.client.delete(table).where(table.id.equals(id)).returning();
+    if (tenantID) {
+      query = query.where(table.tenantId.equals(tenantID));
+    }
+    const result = await query;
+    if (result.length === 0) {
+      throw new Error(`Document not found: ${slug}/${id}`);
+    }
+    return this.processResult(result[0], config);
+  }
+  async count(args) {
+    const { collection: slug, where = {}, tenantID } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    const filters = this.buildWhereClause(where, config, tenantID);
+    try {
+      const result = await this.client.select({ count: `count(*)` }).from(table).where(filters);
+      return parseInt(result[0]?.count || "0");
+    } catch {
+      return 0;
+    }
+  }
+  async findOne(args) {
+    const { collection: slug, where = {}, tenantID } = args;
+    const config = this.getCollection(slug);
+    const table = this.getTable(slug);
+    const filters = this.buildWhereClause(where, config, tenantID);
+    const results = await this.client.select().from(table).where(filters).limit(1);
+    if (results.length === 0) return null;
+    return this.processResult(results[0], config);
+  }
+  async findVersions(args) {
+    const { collection: slug, where = {}, sort, limit = 10, page = 1 } = args;
+    return {
+      docs: [],
+      ...this.calculatePagination(page, limit, 0)
+    };
+  }
+  async findVersionByID(args) {
+    return null;
+  }
+  async createVersion(args) {
+    return args.data;
+  }
+  async deleteVersions(args) {
+  }
+  // ========================================================================
+  // Helper Methods
+  // ========================================================================
+  getTable(slug) {
+    const tableName = this.getTableName(slug);
+    const table = this.schema[tableName];
+    if (!table) {
+      throw new Error(`Table "${tableName}" not found in schema`);
+    }
+    return table;
+  }
+  buildWhereClause(where, config, tenantID) {
+    const conditions = [];
+    if (tenantID && config.tenantScoped) {
+      conditions.push({ tenantId: tenantID });
+    }
+    for (const [key, value] of Object.entries(where)) {
+      if (key === "AND" && Array.isArray(value)) {
+        for (const subCondition of value) {
+          conditions.push(...Object.entries(subCondition).map(([k, v]) => ({ [k]: v })));
+        }
+      } else if (key === "OR" && Array.isArray(value)) {
+        conditions.push(...value.flatMap(
+          (v) => Object.entries(v).map(([k, val]) => ({ [k]: val }))
+        ));
+      } else if (typeof value === "object" && value !== null) {
+        if (value.equals !== void 0) conditions.push({ [key]: value.equals });
+        if (value.not_equals !== void 0) conditions.push({ [key]: { not: value.not_equals } });
+        if (value.in) conditions.push({ [key]: { in: value.in } });
+        if (value.like) conditions.push({ [key]: { like: value.like } });
+        if (value.greater_than !== void 0) conditions.push({ [key]: { gt: value.greater_than } });
+        if (value.greater_than_equal !== void 0) conditions.push({ [key]: { gte: value.greater_than_equal } });
+        if (value.less_than !== void 0) conditions.push({ [key]: { lt: value.less_than } });
+        if (value.less_than_equal !== void 0) conditions.push({ [key]: { lte: value.less_than_equal } });
+      } else {
+        conditions.push({ [key]: value });
+      }
+    }
+    return conditions.length > 0 ? conditions : void 0;
+  }
+  processResult(data, config) {
+    if (!data) return null;
+    const result = { ...data };
+    if (data.id) {
+      result.id = String(data.id);
+    }
+    for (const field of config.fields) {
+      if (field.type === "json" || field.type === "richtext" || field.type === "array" || field.type === "group" || field.type === "blocks") {
+        if (result[field.name] && typeof result[field.name] === "string") {
+          try {
+            result[field.name] = JSON.parse(result[field.name]);
+          } catch {
+          }
+        }
+      }
+    }
+    if (result.createdAt) {
+      result.createdAt = new Date(result.createdAt).toISOString();
+    }
+    if (result.updatedAt) {
+      result.updatedAt = new Date(result.updatedAt).toISOString();
+    }
+    return result;
+  }
+};
+function createDrizzleAdapter(options) {
+  return new DrizzleAdapter(options);
+}
+
+exports.DrizzleAdapter = DrizzleAdapter;
+exports.collectionToDrizzleSchema = collectionToDrizzleSchema;
+exports.createDrizzleAdapter = createDrizzleAdapter;
+exports.fieldToDrizzleType = fieldToDrizzleType;
+//# sourceMappingURL=chunk-3Q3FS5J4.cjs.map
+//# sourceMappingURL=chunk-3Q3FS5J4.cjs.map