@kyro-cms/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,525 @@
+import { KyroRouter } from './trpc/index.js';
+export { createContext, createCountProcedure, createCreateProcedure, createDeleteProcedure, createDynamicRouter, createFindByIDProcedure, createFindProcedure, createKyroServer, createUpdateProcedure } from './trpc/index.js';
+import * as graphql from 'graphql';
+import * as hono from 'hono';
+import * as hono_types from 'hono/types';
+import { R as Registry } from './index-4fJKLFK2.js';
+export { c as createRegistry, g as getRegistry, r as resetRegistry } from './index-4fJKLFK2.js';
+import { B as BaseAdapter, K as KyroConfig, f as User, g as Request, C as CollectionConfig, G as GlobalConfig, F as Field, a as FindArgs, b as FindResult, c as FindByIDArgs, d as CreateArgs, U as UpdateArgs, D as DeleteArgs, H as Hook } from './types-BGM5MV_K.js';
+export { A as ALL_FIELD_TYPES, h as AccessArgs, i as AccessControl, j as AdapterConfig, k as AdminConfig, l as ArrayField, m as AuthConfig, n as BaseField, o as Block, p as BlocksField, q as COMPLEX_FIELD_TYPES, r as CheckboxField, s as CodeField, t as CollapsibleField, u as CollectionAccess, v as CollectionHooks, w as ColorField, x as CreateResult, y as DateField, E as EmailField, z as FieldAccess, I as FieldAdmin, J as FieldHooks, L as FieldType, M as GlobalAccess, N as GlobalHooks, O as GroupField, Q as HookArgs, S as ImageSize, T as JSONField, V as LAYOUT_FIELD_TYPES, W as MarkdownField, X as NumberField, Y as PRIMITIVE_FIELD_TYPES, Z as PasswordField, P as PluginConfig, _ as RELATIONAL_FIELD_TYPES, $ as RadioField, R as RelationshipField, a0 as RichTextBlock, a1 as RichTextField, a2 as RowField, a3 as SelectField, a4 as TabsField, a5 as TextField, a6 as TextareaField, a7 as UploadConfig, e as UploadField, a8 as ValidateOptions, a9 as VersionConfig, aa as WhereClause, ab as evaluateAccess, ac as getWhereClause, ad as isArrayField, ae as isBlocksField, af as isGroupField, ag as isLayoutField, ah as isNumberField, ai as isRelationshipField, aj as isRichTextField, ak as isSelectField, al as isTextField, am as isUploadField, an as mergeWhereClauses, ao as runFieldHooks, ap as runHooks } from './types-BGM5MV_K.js';
+import { KyroPubSub, KyroWSServer } from './ws/index.js';
+export { PubSub, createWSServer } from './ws/index.js';
+import { ZodTypeAny } from 'zod';
+export { z } from 'zod';
+import { A as AbstractBaseAdapter } from './base-CQkFzqQl.js';
+export { DrizzleAdapter, collectionToDrizzleSchema, createDrizzleAdapter, fieldToDrizzleType } from './drizzle/index.js';
+export { MongoDBAdapter, createMongoDBAdapter } from './mongodb/index.js';
+export { buildGraphQLSchema, createGraphQLSchema } from './graphql/index.js';
+export { createHonoApp, createRESTAPI } from './rest/index.js';
+import 'ws';
+
+declare class Kyro {
+    registry: Registry;
+    db: BaseAdapter;
+    pubsub: KyroPubSub;
+    private wsServer?;
+    private config;
+    constructor(config: KyroConfig);
+    init(): Promise<void>;
+    getREST(options?: {
+        user?: User;
+        req?: Request;
+        tenantID?: string;
+    }): hono.Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+    getGraphQL(options?: {
+        user?: User;
+        req?: Request;
+        tenantID?: string;
+    }): graphql.GraphQLSchema;
+    getTRPC(options?: {
+        user?: User;
+        req?: Request;
+        tenantID?: string;
+    }): KyroRouter;
+    startWebSocket(options?: {
+        port?: number;
+        requireAuth?: boolean;
+        verifyToken?: (token: string) => Promise<any>;
+    }): Promise<KyroWSServer>;
+    shutdown(): Promise<void>;
+}
+declare function createKyro(config: KyroConfig): Kyro;
+
+declare class ConfigValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+declare function validateCollection(config: CollectionConfig): string[];
+declare function validateGlobal(config: GlobalConfig): string[];
+declare function validateFields(fields: Field[], context: string): string[];
+declare function validateConfig(collections: CollectionConfig[], globals?: GlobalConfig[]): void;
+
+declare function fieldToZod(field: Field): ZodTypeAny;
+declare function collectionToZod(collection: CollectionConfig): ZodTypeAny;
+declare function collectionToCreateZod(collection: CollectionConfig): ZodTypeAny;
+declare function collectionToUpdateZod(collection: CollectionConfig): ZodTypeAny;
+declare function collectionToWhereZod(collection: CollectionConfig): ZodTypeAny;
+declare function globalToZod(global: GlobalConfig): ZodTypeAny;
+
+type DatabaseType = 'postgres' | 'mysql' | 'sqlite' | 'mongodb';
+interface DatabaseConnectionOptions {
+    type: DatabaseType;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    url?: string;
+    ssl?: boolean | Record<string, any>;
+    maxConnections?: number;
+    connectionTimeout?: number;
+}
+interface DrizzleAdapterOptions {
+    type: 'postgres' | 'mysql' | 'sqlite';
+    client: any;
+    schema?: any;
+    connectionOptions?: DatabaseConnectionOptions;
+}
+interface MongoDBAdapterOptions {
+    type: 'mongodb';
+    client: any;
+    database: string;
+    connectionOptions?: DatabaseConnectionOptions;
+}
+type AdapterOptions = DrizzleAdapterOptions | MongoDBAdapterOptions;
+
+declare class LocalAdapter extends AbstractBaseAdapter {
+    private db;
+    private migrations;
+    constructor(options: {
+        db?: any;
+        path?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private ensureTable;
+    private fieldToSQL;
+    find<T>(args: FindArgs): Promise<FindResult<T>>;
+    findByID<T>(args: FindByIDArgs): Promise<T | null>;
+    create<T>(args: CreateArgs): Promise<T>;
+    update<T>(args: UpdateArgs): Promise<T>;
+    delete<T>(args: DeleteArgs): Promise<T>;
+    count(args: {
+        collection: string;
+        where?: Record<string, any>;
+        tenantID?: string;
+    }): Promise<number>;
+    findOne(args: {
+        collection: string;
+        where: Record<string, any>;
+        tenantID?: string;
+    }): Promise<any>;
+    findVersions(): Promise<FindResult<any>>;
+    findVersionByID(): Promise<any>;
+    createVersion(): Promise<any>;
+    deleteVersions(): Promise<void>;
+    private rowToDoc;
+    private generateId;
+    private getTableNameFor;
+    migrate(): Promise<void>;
+    rollback(): Promise<void>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    getDatabase(): any;
+    exec(sql: string): void;
+    prepare(sql: string): any;
+}
+declare function createLocalAdapter(options?: {
+    db?: any;
+    path?: string;
+}): LocalAdapter;
+
+interface PluginHooks {
+    beforeInit?: Hook[];
+    afterInit?: Hook[];
+    beforeRegisterCollections?: Hook[];
+    afterRegisterCollections?: Hook[];
+    beforeRegisterGlobals?: Hook[];
+    afterRegisterGlobals?: Hook[];
+    beforeServerStart?: Hook[];
+    afterServerStart?: Hook[];
+    beforeServerStop?: Hook[];
+    afterServerStop?: Hook[];
+}
+interface PluginCollectionExtension {
+    slug: string;
+    config: Partial<CollectionConfig>;
+}
+interface PluginGlobalExtension {
+    slug: string;
+    config: Partial<GlobalConfig>;
+}
+interface PluginFieldExtension {
+    collectionSlug: string;
+    field: Field;
+}
+interface PluginAPI {
+    registry: {
+        getCollection: (slug: string) => CollectionConfig | undefined;
+        getCollections: () => CollectionConfig[];
+        getGlobal: (slug: string) => GlobalConfig | undefined;
+        addCollection: (config: CollectionConfig) => void;
+        addGlobal: (config: GlobalConfig) => void;
+        extendCollection: (slug: string, extension: Partial<CollectionConfig>) => void;
+        extendGlobal: (slug: string, extension: Partial<GlobalConfig>) => void;
+        addField: (collectionSlug: string, field: Field, position?: number) => void;
+    };
+    hooks: {
+        register: (event: string, handler: Hook) => void;
+        unregister: (event: string, handler: Hook) => void;
+    };
+    config: {
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+    };
+    db: any;
+}
+declare abstract class KyroPlugin {
+    name: string;
+    version?: string;
+    description?: string;
+    hooks: PluginHooks;
+    collections: Partial<CollectionConfig>[];
+    globals: Partial<GlobalConfig>[];
+    fields: PluginFieldExtension[];
+    extensions: {
+        collections: PluginCollectionExtension[];
+        globals: PluginGlobalExtension[];
+    };
+    adminComponents: Record<string, any>;
+    adminStyles: string[];
+    serverMiddleware?: (app: any) => void;
+    clientMiddleware?: (req: any) => any;
+    constructor(name: string);
+    init?(api: PluginAPI): Promise<void>;
+    beforeInit?(api: PluginAPI): Promise<void>;
+    afterInit?(api: PluginAPI): Promise<void>;
+    getCollections?(): Partial<CollectionConfig>[];
+    getGlobals?(): Partial<GlobalConfig>[];
+    getHooks?(): PluginHooks;
+}
+declare class PluginManager {
+    private plugins;
+    private hooks;
+    register(plugin: KyroPlugin): void;
+    unregister(name: string): void;
+    get(name: string): KyroPlugin | undefined;
+    getAll(): KyroPlugin[];
+    has(name: string): boolean;
+    registerHook(event: string, handler: Hook): void;
+    unregisterHook(event: string, handler: Hook): void;
+    executeHook(event: string, args?: any): Promise<any>;
+    getAllCollections(): Partial<CollectionConfig>[];
+    getAllGlobals(): Partial<GlobalConfig>[];
+    getAllFields(): PluginFieldExtension[];
+    getAdminComponents(): Record<string, any>;
+    getAdminStyles(): string[];
+}
+declare class SEOPLugin extends KyroPlugin {
+    constructor();
+}
+declare class AnalyticsPlugin extends KyroPlugin {
+    constructor();
+}
+declare class CommentsPlugin extends KyroPlugin {
+    constructor();
+}
+declare class ReviewsPlugin extends KyroPlugin {
+    constructor();
+}
+declare class WishlistPlugin extends KyroPlugin {
+    constructor();
+}
+declare const presetPlugins: {
+    SEO: typeof SEOPLugin;
+    Analytics: typeof AnalyticsPlugin;
+    Comments: typeof CommentsPlugin;
+    Reviews: typeof ReviewsPlugin;
+    Wishlist: typeof WishlistPlugin;
+};
+
+type StylingMode = 'css' | 'tailwind' | 'css-in-js' | 'styled-components' | 'vanilla-extract';
+interface StylingConfig {
+    mode: StylingMode;
+    theme?: ThemeConfig;
+    customProperties?: Record<string, string>;
+}
+interface ThemeConfig {
+    colors?: ThemeColors;
+    fonts?: ThemeFonts;
+    spacing?: ThemeSpacing;
+    borderRadius?: ThemeBorderRadius;
+    shadows?: ThemeShadows;
+    breakpoints?: Record<string, string>;
+}
+interface ThemeColors {
+    primary?: string;
+    secondary?: string;
+    accent?: string;
+    background?: string;
+    surface?: string;
+    text?: string;
+    textMuted?: string;
+    border?: string;
+    error?: string;
+    warning?: string;
+    success?: string;
+    info?: string;
+}
+interface ThemeFonts {
+    sans?: string;
+    serif?: string;
+    mono?: string;
+}
+interface ThemeSpacing {
+    xs?: string;
+    sm?: string;
+    md?: string;
+    lg?: string;
+    xl?: string;
+    '2xl'?: string;
+    '3xl'?: string;
+    '4xl'?: string;
+}
+interface ThemeBorderRadius {
+    sm?: string;
+    md?: string;
+    lg?: string;
+    xl?: string;
+    full?: string;
+}
+interface ThemeShadows {
+    sm?: string;
+    md?: string;
+    lg?: string;
+    xl?: string;
+}
+declare class CSSGenerator {
+    private config;
+    private css;
+    constructor(config: StylingConfig);
+    addRule(selector: string, properties: Record<string, string>): this;
+    addMediaQuery(breakpoint: string, rules: string[]): this;
+    generate(): string;
+}
+declare function generateTailwindConfig(theme: ThemeConfig): Record<string, any>;
+declare const defaultLightTheme: ThemeConfig;
+declare const defaultDarkTheme: ThemeConfig;
+declare const ecommerce2026Theme: ThemeConfig;
+declare function generateCSSVariables(theme: ThemeConfig): string;
+interface AdminStylingConfig {
+    mode: StylingMode;
+    theme?: ThemeConfig;
+    customStyles?: string;
+    componentOverrides?: Record<string, Record<string, string>>;
+}
+declare function createAdminStyling(config: AdminStylingConfig): string;
+interface FieldStyling {
+    wrapper?: Record<string, string>;
+    label?: Record<string, string>;
+    input?: Record<string, string>;
+    error?: Record<string, string>;
+    description?: Record<string, string>;
+}
+declare const defaultFieldStyling: Record<string, FieldStyling>;
+
+interface AuthUser {
+    id: string;
+    email: string;
+    passwordHash?: string;
+    role: UserRole;
+    tenant?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type UserRole = 'admin' | 'editor' | 'author' | 'customer' | 'vendor';
+interface Session {
+    id: string;
+    userId: string;
+    token: string;
+    expiresAt: Date;
+    createdAt: Date;
+    ipAddress?: string;
+    userAgent?: string;
+}
+interface JWTPayload {
+    sub: string;
+    email: string;
+    role: UserRole;
+    tenant?: string;
+    iat: number;
+    exp: number;
+}
+interface AuthTokenConfig {
+    secret: string;
+    expiresIn?: string | number;
+    refreshExpiresIn?: string | number;
+    issuer?: string;
+    audience?: string[];
+    saltRounds?: number;
+}
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface RegisterData {
+    email: string;
+    password: string;
+    role?: UserRole;
+    tenant?: string;
+}
+interface AuthResult {
+    success: boolean;
+    user?: AuthUser;
+    session?: Session;
+    token?: string;
+    error?: string;
+}
+interface AuthAdapter {
+    createUser(data: {
+        email: string;
+        passwordHash: string;
+        role: UserRole;
+        tenant?: string;
+    }): Promise<AuthUser>;
+    findUserByEmail(email: string): Promise<AuthUser | null>;
+    findUserById(id: string): Promise<AuthUser | null>;
+    updateUser(id: string, data: Partial<AuthUser>): Promise<AuthUser>;
+    deleteUser(id: string): Promise<void>;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+    hashPassword(password: string): Promise<string>;
+    createSession(userId: string, token: string, expiresAt: Date): Promise<Session>;
+    findSessionByToken(token: string): Promise<Session | null>;
+    deleteSession(token: string): Promise<void>;
+    deleteUserSessions(userId: string): Promise<void>;
+}
+
+declare class Auth {
+    private adapter;
+    private config;
+    constructor(adapter: AuthAdapter, config: AuthTokenConfig);
+    register(data: RegisterData): Promise<AuthResult>;
+    login(credentials: LoginCredentials): Promise<AuthResult>;
+    logout(token: string): Promise<void>;
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    verifyToken(token: string): Promise<JWTPayload | null>;
+    getUserFromToken(token: string): Promise<AuthUser | null>;
+    changePassword(userId: string, currentPassword: string, newPassword: string): Promise<AuthResult>;
+    resetPassword(email: string, newPassword: string): Promise<AuthResult>;
+    deleteAccount(userId: string): Promise<AuthResult>;
+    private createSessionForUser;
+    private generateToken;
+    private hashPassword;
+    private parseExpiresIn;
+}
+declare function createAuth(adapter: AuthAdapter, config: AuthTokenConfig): Auth;
+
+type VersionStatus = 'draft' | 'published' | 'archived';
+interface Version<T = Record<string, unknown>> {
+    id: string;
+    collection: string;
+    documentId: string;
+    version: number;
+    status: VersionStatus;
+    data: T;
+    createdBy: string;
+    createdAt: Date;
+    publishedAt?: Date;
+    changeDescription?: string;
+}
+interface VersionDiff {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+interface VersionHistoryOptions {
+    collection: string;
+    documentId: string;
+    limit?: number;
+    offset?: number;
+}
+interface CreateVersionOptions<T = Record<string, unknown>> {
+    collection: string;
+    documentId: string;
+    data: T;
+    status?: VersionStatus;
+    createdBy: string;
+    changeDescription?: string;
+}
+interface PublishVersionOptions {
+    collection: string;
+    documentId: string;
+    versionId: string;
+    publishedBy: string;
+}
+interface CompareVersionsOptions {
+    collection: string;
+    documentId: string;
+    versionA: string | number;
+    versionB: string | number;
+}
+interface VersionAdapter {
+    createVersion<T>(options: CreateVersionOptions<T>): Promise<Version<T>>;
+    getVersion<T>(collection: string, versionId: string): Promise<Version<T> | null>;
+    getVersions<T>(options: VersionHistoryOptions): Promise<Version<T>[]>;
+    getLatestVersion<T>(collection: string, documentId: string): Promise<Version<T> | null>;
+    getPublishedVersion<T>(collection: string, documentId: string): Promise<Version<T> | null>;
+    publishVersion(options: PublishVersionOptions): Promise<void>;
+    revertToVersion<T>(options: {
+        collection: string;
+        documentId: string;
+        versionId: string;
+        userId: string;
+    }): Promise<Version<T>>;
+    compareVersions<T>(options: CompareVersionsOptions): Promise<VersionDiff[]>;
+    deleteVersions(collection: string, documentId: string): Promise<void>;
+}
+interface DraftPublishConfig {
+    enabled?: boolean;
+    draftsEnabled?: boolean;
+    publishEnabled?: boolean;
+    scheduleEnabled?: boolean;
+    versioningEnabled?: boolean;
+    maxVersionsPerDocument?: number;
+    autoPublish?: boolean;
+    requirePublishPermission?: boolean;
+}
+interface VersionPublishSchedule {
+    versionId: string;
+    scheduledFor: Date;
+    status: 'pending' | 'published' | 'cancelled';
+}
+declare function getDefaultDraftPublishConfig(): Required<DraftPublishConfig>;
+
+declare class VersionManager<T = Record<string, unknown>> {
+    private adapter;
+    private config;
+    constructor(adapter: VersionAdapter, config?: DraftPublishConfig);
+    createVersion(options: Omit<CreateVersionOptions<T>, 'version'>): Promise<Version<T>>;
+    publishVersion(options: PublishVersionOptions): Promise<void>;
+    unpublishDocument(collection: string, documentId: string): Promise<void>;
+    revertToVersion(collection: string, documentId: string, versionId: string, userId: string): Promise<Version<T>>;
+    getVersionHistory(collection: string, documentId: string, limit?: number, offset?: number): Promise<Version<T>[]>;
+    compareTwoVersions(collection: string, documentId: string, versionA: string | number, versionB: string | number): Promise<VersionDiff[]>;
+    getLatestDraft(collection: string, documentId: string): Promise<Version<T> | null>;
+    getPublishedVersion(collection: string, documentId: string): Promise<Version<T> | null>;
+    getVersion(collection: string, versionId: string): Promise<Version<T> | null>;
+    schedulePublish(collection: string, documentId: string, versionId: string, scheduledFor: Date): Promise<void>;
+    deleteVersionHistory(collection: string, documentId: string): Promise<void>;
+    private pruneOldVersions;
+}
+declare function createVersionManager<T>(adapter: VersionAdapter, config?: DraftPublishConfig): VersionManager<T>;
+declare function isPublished(status: VersionStatus): boolean;
+declare function isDraft(status: VersionStatus): boolean;
+declare function isArchived(status: VersionStatus): boolean;
+
+export { AbstractBaseAdapter, type AdapterOptions, type AdminStylingConfig, AnalyticsPlugin, Auth, type AuthAdapter, type AuthResult, type Session as AuthSession, type AuthTokenConfig, type AuthUser, BaseAdapter, CSSGenerator, CollectionConfig, CommentsPlugin, type CompareVersionsOptions, ConfigValidationError, CreateArgs, type CreateVersionOptions, type DatabaseConnectionOptions, type DatabaseType, DeleteArgs, type DraftPublishConfig, type DrizzleAdapterOptions, Field, type FieldStyling, FindArgs, FindByIDArgs, FindResult, GlobalConfig, Hook, type JWTPayload, Kyro, KyroConfig, KyroPlugin, KyroPubSub, KyroWSServer, LocalAdapter, type LoginCredentials, type MongoDBAdapterOptions, type PluginAPI, type PluginHooks, PluginManager, type PublishVersionOptions, type RegisterData, Registry, Request, ReviewsPlugin, SEOPLugin, type StylingConfig, type StylingMode, type ThemeBorderRadius, type ThemeColors, type ThemeConfig, type ThemeFonts, type ThemeShadows, type ThemeSpacing, UpdateArgs, User, type UserRole, type Version, type VersionAdapter, type VersionDiff, type VersionHistoryOptions, VersionManager, type VersionPublishSchedule, type VersionStatus, WishlistPlugin, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createAdminStyling, createAuth, createKyro, createLocalAdapter, createVersionManager, defaultDarkTheme, defaultFieldStyling, defaultLightTheme, ecommerce2026Theme, fieldToZod, generateCSSVariables, generateTailwindConfig, getDefaultDraftPublishConfig, globalToZod, isArchived, isDraft, isPublished, presetPlugins, validateCollection, validateConfig, validateFields, validateGlobal };