@kyro-cms/core 0.5.4 → 0.5.5

package/dist/types-J3R9nVsZ.d.cts

@@ -0,0 +1,461 @@
+import { F as Field } from './types-VtjUxIMp.cjs';
+
+interface Request {
+    body?: any;
+    headers: Record<string, string>;
+    method?: string;
+    url?: string;
+    cookies?: Record<string, string>;
+    query?: Record<string, any>;
+}
+interface User {
+    id: string;
+    email: string;
+    role: string;
+    tenantID?: string;
+    [key: string]: any;
+}
+interface HookArgs<T = any> {
+    collection?: string;
+    global?: string;
+    data?: T;
+    originalDoc?: T;
+    doc?: T;
+    req: Request;
+    user?: User;
+    operation: 'create' | 'read' | 'update' | 'delete';
+    tenantID?: string;
+    field?: string;
+    siblingData?: Record<string, any>;
+    value?: any;
+    previousValue?: any;
+    context?: Record<string, any>;
+}
+type Hook<T = any> = (args: HookArgs<T>) => Promise<T | void> | T | void;
+interface CollectionHooks {
+    beforeValidate?: Hook[];
+    beforeChange?: Hook[];
+    afterChange?: Hook[];
+    beforeRead?: Hook[];
+    afterRead?: Hook[];
+    beforeDelete?: Hook[];
+    afterDelete?: Hook[];
+    beforeLogin?: Hook[];
+    afterLogin?: Hook[];
+    afterLogout?: Hook[];
+    afterRefresh?: Hook[];
+    afterForgotPassword?: Hook[];
+}
+interface FieldHooks {
+    beforeValidate?: Hook[];
+    beforeChange?: Hook[];
+    afterChange?: Hook[];
+    afterRead?: Hook[];
+}
+interface GlobalHooks {
+    beforeValidate?: Hook[];
+    beforeChange?: Hook[];
+    afterChange?: Hook[];
+    beforeRead?: Hook[];
+    afterRead?: Hook[];
+}
+declare function runHooks(hooks: Hook[], args: HookArgs): Promise<any>;
+declare function runFieldHooks(hooks: Hook[], args: HookArgs): Promise<any>;
+
+interface WhereClause {
+    [field: string]: any;
+}
+interface AccessArgs {
+    req: Request;
+    user?: User;
+    data?: any;
+    doc?: any;
+    id?: string;
+    tenantID?: string;
+    context?: Record<string, any>;
+}
+type AccessControl = boolean | ((args: AccessArgs) => Promise<boolean | WhereClause> | boolean | WhereClause);
+interface CollectionAccess {
+    create?: AccessControl;
+    read?: AccessControl;
+    update?: AccessControl;
+    delete?: AccessControl;
+    admin?: AccessControl;
+    unlock?: AccessControl;
+    readVersions?: AccessControl;
+}
+interface GlobalAccess {
+    read?: AccessControl;
+    update?: AccessControl;
+}
+interface FieldAccess {
+    create?: AccessControl;
+    read?: AccessControl;
+    update?: AccessControl;
+}
+declare function evaluateAccess(access: AccessControl, args: AccessArgs): Promise<boolean | WhereClause>;
+declare function mergeWhereClauses(...whereClauses: (WhereClause | boolean | undefined)[]): WhereClause;
+declare function getWhereClause(access: AccessControl, args: AccessArgs): Promise<WhereClause | undefined>;
+
+interface AdminConfig {
+    useAsTitle?: string;
+    defaultColumns?: string[];
+    hidden?: boolean;
+    description?: string;
+    hideAPIURL?: boolean;
+    group?: string;
+    icon?: string;
+    preview?: (doc: any, options: {
+        req: any;
+    }) => string;
+    disableDuplicate?: boolean;
+    pagination?: {
+        defaultLimit?: number;
+        limits?: number[];
+    };
+    layout?: "split" | "single";
+}
+interface UploadConfig {
+    staticDir?: string;
+    staticURL?: string;
+    mimeTypes?: string[];
+    fileSize?: number;
+    imageSizes?: ImageSize[];
+    crop?: boolean;
+    focalPoint?: boolean;
+    formatOptions?: {
+        format: "webp" | "png" | "jpg";
+        options?: Record<string, any>;
+    };
+    resizeOptions?: Record<string, any>;
+    adminThumbnail?: string;
+}
+interface ImageSize {
+    name: string;
+    width?: number;
+    height?: number;
+    crop?: string;
+    position?: string;
+    formatOptions?: {
+        format: "webp" | "png" | "jpg";
+    };
+    generateImageName?: (doc: any) => string;
+}
+interface VersionConfig {
+    maxPerDoc?: number;
+    drafts?: boolean;
+    retainDeleted?: boolean;
+}
+type DocumentStatus = 'draft' | 'published' | 'archived';
+interface AuthConfig {
+    tokenExpiration?: number;
+    verify?: boolean | {
+        generateEmailHTML?: (args: any) => string;
+    };
+    maxLoginAttempts?: number;
+    lockTime?: number;
+    cookies?: {
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none";
+        domain?: string;
+    };
+    forgotPassword?: {
+        generateEmailHTML?: (args: any) => string;
+        generateEmailSubject?: (args: any) => string;
+    };
+    strategies?: Array<{
+        name: string;
+        authenticate: (args: any) => Promise<any>;
+    }>;
+}
+interface CollectionConfig {
+    slug: string;
+    label?: string;
+    labelPlural?: string;
+    singularLabel?: string;
+    admin?: AdminConfig;
+    fields: Field[];
+    access?: CollectionAccess;
+    hooks?: CollectionHooks;
+    timestamps?: boolean;
+    tenantScoped?: boolean;
+    tenantField?: string;
+    upload?: UploadConfig;
+    versions?: VersionConfig;
+    auth?: boolean | AuthConfig;
+    graphQL?: {
+        singularName?: string;
+        pluralName?: string;
+    };
+    indexes?: Array<{
+        fields: Record<string, number | "text">;
+        options?: Record<string, any>;
+    }>;
+    custom?: Record<string, any>;
+    tabs?: Array<{
+        label: string;
+        fields: Field[];
+        name?: string;
+    }>;
+}
+interface GlobalConfig {
+    slug: string;
+    label?: string;
+    admin?: AdminConfig;
+    fields: Field[];
+    access?: GlobalAccess;
+    hooks?: GlobalHooks;
+    versions?: VersionConfig;
+    graphQL?: {
+        name?: string;
+    };
+    typescript?: {
+        interface?: string;
+    };
+    custom?: Record<string, any>;
+    tabs?: Array<{
+        label: string;
+        fields: Field[];
+        name?: string;
+    }>;
+}
+interface FindArgs {
+    collection: string;
+    where?: Record<string, any>;
+    sort?: string;
+    limit?: number;
+    page?: number;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+    /** If true, returns draft docs (admin view). If false/omitted, only published docs are returned (public API). */
+    draft?: boolean;
+}
+interface FindByIDArgs {
+    collection: string;
+    id: string;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+    /** If true, returns document regardless of status (admin view). */
+    draft?: boolean;
+}
+interface CreateArgs {
+    collection: string;
+    data: Record<string, any>;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface UpdateArgs {
+    collection: string;
+    id: string;
+    data: Record<string, any>;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface DeleteArgs {
+    collection: string;
+    id: string;
+    tenantID?: string;
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface FindResult<T = any> {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    totalPages: number;
+    page: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+}
+interface DraftSnapshot<T = Record<string, any>> {
+    id: string;
+    collection: string;
+    documentId: string;
+    tenantID?: string;
+    data: T;
+    baseUpdatedAt?: string | null;
+    draftUpdatedAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface DraftFindArgs {
+    collection: string;
+    documentId: string;
+    tenantID?: string;
+}
+interface DraftUpsertArgs<T = Record<string, any>> extends DraftFindArgs {
+    data: T;
+    baseUpdatedAt?: string | null;
+    draftUpdatedAt?: string;
+}
+interface DraftDeleteArgs extends DraftFindArgs {
+}
+interface CreateResult<T = any> {
+    doc: T;
+    errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+interface VersionRecord<T = Record<string, any>> {
+    id: string;
+    collection: string;
+    documentId: string;
+    version: number;
+    status: DocumentStatus;
+    data: T;
+    createdBy?: string;
+    createdAt: string;
+    updatedAt: string;
+    publishedAt?: string | null;
+    changeDescription?: string;
+}
+interface CreateVersionArgs<T = Record<string, any>> {
+    collection: string;
+    documentId: string;
+    data: T;
+    status: DocumentStatus;
+    createdBy?: string;
+    changeDescription?: string;
+    tenantID?: string;
+}
+interface FindVersionsArgs {
+    collection: string;
+    documentId: string;
+    tenantID?: string;
+    limit?: number;
+    page?: number;
+    sort?: string;
+}
+interface BaseAdapter {
+    init(collections: CollectionConfig[], globals: GlobalConfig[]): Promise<void>;
+    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;
+        draft?: boolean;
+    }): Promise<any>;
+    findVersions(args: FindVersionsArgs): Promise<FindResult<VersionRecord>>;
+    findVersionByID(args: {
+        collection: string;
+        versionId: string;
+        tenantID?: string;
+    }): Promise<VersionRecord | null>;
+    createVersion<T = Record<string, any>>(args: CreateVersionArgs<T>): Promise<VersionRecord<T>>;
+    deleteVersions(args: {
+        collection: string;
+        documentId: string;
+        keepLatest?: number;
+        tenantID?: string;
+    }): Promise<void>;
+    findDraft<T = Record<string, any>>(args: DraftFindArgs): Promise<DraftSnapshot<T> | null>;
+    upsertDraft<T = Record<string, any>>(args: DraftUpsertArgs<T>): Promise<DraftSnapshot<T>>;
+    deleteDraft(args: DraftDeleteArgs): Promise<void>;
+    migrate?(): Promise<void>;
+    rollback?(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction?<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+}
+interface AdapterConfig {
+    type: "drizzle" | "mongodb";
+    client: any;
+    schema?: any;
+    connectionOptions?: Record<string, any>;
+}
+interface PluginConfig {
+    name: string;
+    version?: string;
+    init?: (kyro: any) => void | Promise<void>;
+    extendCollection?: (slug: string, config: CollectionConfig) => CollectionConfig;
+    extendGlobal?: (slug: string, config: GlobalConfig) => GlobalConfig;
+    hooks?: CollectionHooks;
+    fields?: Field[];
+    api?: (kyro: any) => any;
+}
+interface KyroConfig {
+    collections?: CollectionConfig[];
+    globals?: GlobalConfig[];
+    adapter: BaseAdapter;
+    plugins?: PluginConfig[];
+    auth?: boolean | {
+        secret?: string;
+        tokenExpiration?: number;
+        cookie?: {
+            secure?: boolean;
+            sameSite?: "strict" | "lax" | "none";
+            domain?: string;
+        };
+        checkSession?: boolean;
+    };
+    authAdapter?: any;
+    cors?: {
+        origins?: string[];
+        credentials?: boolean;
+    };
+    admin?: {
+        meta?: {
+            title?: string;
+            description?: string;
+            ogImage?: string;
+        };
+        dateFormat?: string;
+        avatar?: "default" | "gravatar";
+        disable?: boolean;
+        indexRoute?: string;
+        components?: Record<string, any>;
+    };
+    upload?: {
+        limits?: {
+            fileSize?: number;
+        };
+    };
+    graphQL?: {
+        maxComplexity?: number;
+        disablePlayground?: boolean;
+    };
+    typescript?: {
+        outputFile?: string;
+    };
+    localization?: {
+        locales: string[];
+        defaultLocale: string;
+    };
+    rateLimit?: {
+        window?: number;
+        max?: number;
+    };
+    debug?: boolean;
+}
+
+export { type AdminConfig as A, type BaseAdapter as B, type CollectionConfig as C, type DeleteArgs as D, mergeWhereClauses as E, type FindArgs as F, type GlobalConfig as G, type Hook as H, type ImageSize as I, runFieldHooks as J, type KyroConfig as K, runHooks as L, type PluginConfig as P, type Request as R, type UploadConfig as U, type VersionConfig as V, type WhereClause as W, type AuthConfig as a, type FindResult as b, type FindByIDArgs as c, type CreateArgs as d, type UpdateArgs as e, type FindVersionsArgs as f, type VersionRecord as g, type CreateVersionArgs as h, type DraftFindArgs as i, type DraftSnapshot as j, type DraftUpsertArgs as k, type DraftDeleteArgs as l, type User as m, type AccessArgs as n, type AccessControl as o, type AdapterConfig as p, type CollectionAccess as q, type CollectionHooks as r, type CreateResult as s, type FieldAccess as t, type FieldHooks as u, type GlobalAccess as v, type GlobalHooks as w, type HookArgs as x, evaluateAccess as y, getWhereClause as z };

package/dist/types-VtjUxIMp.d.cts

@@ -0,0 +1,246 @@
+interface FieldAdmin {
+    description?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    hidden?: boolean;
+    width?: string;
+    position?: "sidebar" | "main";
+    autoGenerate?: string;
+    action?: string;
+    method?: string;
+    inline?: boolean;
+    condition?: (data: Record<string, any>, siblingData: Record<string, any>) => boolean;
+}
+interface BaseField {
+    name: string;
+    label?: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    defaultValue?: any;
+    admin?: FieldAdmin;
+    validate?: (value: any, options: ValidateOptions) => string | true | Promise<string | true>;
+    hooks?: {
+        beforeValidate?: Hook[];
+        beforeChange?: Hook[];
+        afterChange?: Hook[];
+        afterRead?: Hook[];
+    };
+}
+interface ValidateOptions {
+    data?: Record<string, any>;
+    siblingData?: Record<string, any>;
+    user?: any;
+    operation?: string;
+    required?: boolean;
+}
+type Hook = (args: any) => Promise<any> | any;
+type TextFieldVariant = "text" | "email" | "password" | "url" | "id";
+interface TextField extends BaseField {
+    type: "text";
+    variant?: TextFieldVariant;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    hasMany?: boolean;
+    localized?: boolean;
+}
+interface NumberField extends BaseField {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    integer?: boolean;
+    hasMany?: boolean;
+}
+interface CheckboxField extends BaseField {
+    type: "checkbox";
+}
+interface DateField extends BaseField {
+    type: "date";
+    minDate?: string;
+    maxDate?: string;
+    time?: boolean;
+}
+interface EmailField extends BaseField {
+    type: "email";
+}
+interface PasswordField extends BaseField {
+    type: "password";
+}
+interface TextareaField extends BaseField {
+    type: "textarea";
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+    localized?: boolean;
+}
+interface SelectField extends BaseField {
+    type: "select";
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    hasMany?: boolean;
+    defaultValue?: string | string[];
+}
+interface RadioField extends BaseField {
+    type: "radio";
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    defaultValue?: string;
+}
+interface ColorField extends BaseField {
+    type: "color";
+    format?: "hex" | "rgb" | "hsl";
+    defaultValue?: string;
+}
+interface ImageField extends BaseField {
+    type: "image";
+    minCount?: number;
+    maxCount?: number;
+    allowedTypes?: string[];
+    maxSize?: number;
+}
+interface RichTextBlock {
+    type: string;
+    data: Record<string, any>;
+    children?: RichTextBlock[];
+}
+interface RichTextField extends BaseField {
+    type: "richtext";
+    editor?: "lexical" | "slate" | "blocks";
+    hasBlocks?: boolean;
+    defaultValue?: RichTextBlock[];
+    localized?: boolean;
+}
+interface JSONField extends BaseField {
+    type: "json";
+    defaultValue?: Record<string, any>;
+}
+interface CodeField extends BaseField {
+    type: "code";
+    language?: string;
+    defaultValue?: string;
+}
+interface UploadField extends BaseField {
+    type: "upload";
+    relationTo: string;
+    hasMany?: boolean;
+    maxDepth?: number;
+    defaultValue?: string;
+}
+interface MarkdownField extends BaseField {
+    type: "markdown";
+    localized?: boolean;
+    defaultValue?: string;
+}
+interface RelationshipField extends BaseField {
+    type: "relationship";
+    relationTo: string | string[];
+    hasMany?: boolean;
+    maxDepth?: number;
+    filterOptions?: (args: {
+        data: any;
+        user: any;
+    }) => Record<string, any>;
+    defaultValue?: string | string[];
+}
+interface ArrayField extends BaseField {
+    type: "array";
+    fields: Field[];
+    minRows?: number;
+    maxRows?: number;
+    labels?: {
+        singular?: string;
+        plural?: string;
+    };
+    defaultValue?: Record<string, any>[];
+}
+interface ListField extends BaseField {
+    type: "list";
+    defaultValue?: string[];
+}
+interface GroupField extends BaseField {
+    type: "group";
+    fields: Field[];
+    defaultValue?: Record<string, any>;
+}
+interface BlockImage {
+    url: string;
+    alt?: string;
+}
+interface BlockAdmin {
+    group?: string;
+    images?: {
+        icon?: BlockImage | string;
+        thumbnail?: BlockImage | string;
+    };
+}
+interface Block {
+    slug: string;
+    label: string;
+    fields: Field[];
+    imageURL?: string;
+    admin?: BlockAdmin;
+}
+interface BlocksField extends BaseField {
+    type: "blocks";
+    blocks?: Block[];
+    minRows?: number;
+    maxRows?: number;
+    defaultValue?: Array<{
+        blockType: string;
+        [key: string]: any;
+    }>;
+}
+interface RowField extends Omit<BaseField, "name"> {
+    type: "row";
+    fields: Field[];
+    name?: string;
+}
+interface CollapsibleField extends Omit<BaseField, "name"> {
+    type: "collapsible";
+    fields: Field[];
+    label: string;
+    name?: string;
+}
+interface TabsField extends Omit<BaseField, "name"> {
+    type: "tabs";
+    tabs: Array<{
+        label: string;
+        fields: Field[];
+        name?: string;
+    }>;
+    name?: string;
+}
+interface ButtonField extends BaseField {
+    type: "button";
+    label: string;
+    action?: string;
+    method?: string;
+    inline?: boolean;
+}
+type Field = TextField | NumberField | CheckboxField | DateField | EmailField | PasswordField | TextareaField | SelectField | RadioField | ColorField | ImageField | RichTextField | JSONField | CodeField | UploadField | MarkdownField | RelationshipField | ArrayField | ListField | GroupField | BlocksField | RowField | CollapsibleField | TabsField | ButtonField;
+type FieldType = Field["type"];
+declare function isTextField(field: Field): field is TextField;
+declare function isNumberField(field: Field): field is NumberField;
+declare function isRelationshipField(field: Field): field is RelationshipField;
+declare function isArrayField(field: Field): field is ArrayField;
+declare function isGroupField(field: Field): field is GroupField;
+declare function isBlocksField(field: Field): field is BlocksField;
+declare function isUploadField(field: Field): field is UploadField;
+declare function isImageField(field: Field): field is ImageField;
+declare function isRichTextField(field: Field): field is RichTextField;
+declare function isSelectField(field: Field): field is SelectField;
+declare function isLayoutField(field: Field): field is RowField | CollapsibleField | TabsField;
+declare const PRIMITIVE_FIELD_TYPES: readonly ["text", "number", "checkbox", "date", "email", "password", "textarea", "select", "radio", "color"];
+declare const COMPLEX_FIELD_TYPES: readonly ["richtext", "json", "code", "upload", "image", "markdown"];
+declare const RELATIONAL_FIELD_TYPES: readonly ["relationship", "array", "group", "blocks"];
+declare const LAYOUT_FIELD_TYPES: readonly ["row", "collapsible", "tabs"];
+declare const ALL_FIELD_TYPES: readonly ["text", "number", "checkbox", "date", "email", "password", "textarea", "select", "radio", "color", "richtext", "json", "code", "upload", "image", "markdown", "relationship", "array", "group", "blocks", "row", "collapsible", "tabs"];
+declare function createRelationshipFieldConfig(name: string, relationTo: string | string[], options?: Partial<Omit<RelationshipField, "type" | "name" | "relationTo">>): RelationshipField;
+
+export { type ArrayField as A, type BaseField as B, type CheckboxField as C, type DateField as D, type EmailField as E, type Field as F, type GroupField as G, isRichTextField as H, type ImageField as I, type JSONField as J, isSelectField as K, LAYOUT_FIELD_TYPES as L, type MarkdownField as M, type NumberField as N, isTextField as O, type PasswordField as P, isUploadField as Q, type RadioField as R, type SelectField as S, type TabsField as T, type UploadField as U, type ValidateOptions as V, type ButtonField as W, type Hook as X, type ListField as Y, type TextFieldVariant as Z, createRelationshipFieldConfig as _, type Block as a, type BlockAdmin as b, type BlockImage as c, type BlocksField as d, type CodeField as e, type CollapsibleField as f, type ColorField as g, type FieldAdmin as h, type FieldType as i, type RelationshipField as j, type RichTextBlock as k, type RichTextField as l, type RowField as m, type TextField as n, type TextareaField as o, ALL_FIELD_TYPES as p, COMPLEX_FIELD_TYPES as q, PRIMITIVE_FIELD_TYPES as r, RELATIONAL_FIELD_TYPES as s, isArrayField as t, isBlocksField as u, isGroupField as v, isImageField as w, isLayoutField as x, isNumberField as y, isRelationshipField as z };