@kidecms/core 0.1.7 → 0.1.9

package/dist/admin.d.ts

@@ -0,0 +1,33 @@
+import type { CMSConfig, CollectionConfig, FieldConfig } from "./define";
+export declare const initDateFormat: (config: CMSConfig, nextTimeZone?: string) => void;
+export declare const formatDate: (value: unknown) => string;
+export type AdminRoute = {
+    kind: "dashboard";
+} | {
+    kind: "recent";
+} | {
+    kind: "singles";
+} | {
+    kind: "list";
+    collectionSlug: string;
+} | {
+    kind: "new";
+    collectionSlug: string;
+} | {
+    kind: "edit";
+    collectionSlug: string;
+    documentId: string;
+};
+export declare const resolveAdminRoute: (path: string | undefined) => AdminRoute;
+export declare const humanize: (value: string) => string;
+export declare const formatFieldValue: (field: FieldConfig | undefined, value: unknown, relationLabels?: Record<string, string>) => string;
+export declare const getListColumns: (collection: CollectionConfig, viewConfig?: {
+    columns?: string[];
+}) => string[];
+export declare const getFieldSets: (collection: CollectionConfig) => ({
+    fields: string[];
+    position: "content";
+} | {
+    fields: string[];
+    position: "sidebar";
+})[];

package/dist/ai.d.ts

@@ -0,0 +1,15 @@
+export declare function isAiEnabled(): boolean;
+export declare function getAiModel(): Promise<any>;
+export declare function streamAltText(imageUrl: string, filename: string): Promise<any>;
+export declare function streamSeoDescription(content: {
+    title: string;
+    excerpt?: string;
+    body?: string;
+}): Promise<any>;
+export declare function streamTranslation(content: {
+    text: string;
+    sourceLocale: string;
+    targetLocale: string;
+    fieldName: string;
+    fieldType: "text" | "richText" | "slug";
+}): Promise<any>;

package/dist/api.d.ts

@@ -0,0 +1,14 @@
+import type { CMSConfig } from "./define";
+export type FindOptions = {
+    where?: Record<string, unknown>;
+    sort?: {
+        field: string;
+        direction: "asc" | "desc";
+    };
+    limit?: number;
+    offset?: number;
+    status?: "draft" | "published" | "scheduled" | "any";
+    locale?: string;
+    search?: string;
+};
+export declare const createCms: (config: CMSConfig) => any;

package/dist/assets.d.ts

@@ -0,0 +1,51 @@
+export type AssetRecord = {
+    _id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    width: number | null;
+    height: number | null;
+    focalX: number | null;
+    focalY: number | null;
+    alt: string | null;
+    folder: string | null;
+    storagePath: string;
+    url: string;
+    _createdAt: string;
+};
+export type FolderRecord = {
+    _id: string;
+    name: string;
+    parent: string | null;
+    _createdAt: string;
+};
+export declare const assets: {
+    upload(file: File, options?: {
+        alt?: string;
+        folder?: string;
+    }): Promise<AssetRecord>;
+    find(options?: {
+        limit?: number;
+        offset?: number;
+        folder?: string | null;
+    }): Promise<AssetRecord[]>;
+    findById(id: string): Promise<AssetRecord | null>;
+    findByUrl(url: string): Promise<AssetRecord | null>;
+    delete(id: string): Promise<void>;
+    update(id: string, data: {
+        alt?: string;
+        filename?: string;
+        folder?: string | null;
+        focalX?: number | null;
+        focalY?: number | null;
+    }): Promise<AssetRecord | null>;
+    count(): Promise<number>;
+};
+export declare const folders: {
+    create(name: string, parent?: string | null): Promise<FolderRecord>;
+    findByParent(parent: string | null): Promise<FolderRecord[]>;
+    findById(id: string): Promise<FolderRecord | null>;
+    findAll(): Promise<FolderRecord[]>;
+    rename(id: string, name: string): Promise<FolderRecord | null>;
+    delete(id: string): Promise<void>;
+};

package/dist/auth.d.ts

@@ -0,0 +1,30 @@
+export declare const hashPassword: (plain: string) => Promise<string>;
+export declare const verifyPassword: (hash: string, plain: string) => Promise<boolean>;
+export declare const createSession: (userId: string) => Promise<{
+    token: string;
+    expiresAt: string;
+}>;
+export declare const validateSession: (token: string) => Promise<{
+    userId: string;
+    expiresAt: string;
+} | null>;
+export declare const destroySession: (token: string) => Promise<void>;
+export type SessionUser = {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+};
+export declare const getSessionUser: (request: Request) => Promise<SessionUser | null>;
+export declare const createInvite: (userId: string) => Promise<{
+    token: string;
+    expiresAt: string;
+}>;
+export declare const validateInvite: (token: string) => Promise<{
+    userId: string;
+    expiresAt: string;
+} | null>;
+export declare const consumeInvite: (token: string) => Promise<void>;
+export declare const SESSION_COOKIE_NAME = "cms_session";
+export declare const setSessionCookie: (token: string, expiresAt: string) => string;
+export declare const clearSessionCookie: () => string;

package/dist/content.d.ts

@@ -0,0 +1,3 @@
+export declare function parseBlocks(value: unknown): Array<Record<string, any>>;
+export declare function parseList<T = Record<string, any>>(value: unknown): T[];
+export declare function cacheTags(collection: string, docId: string): string[];

package/dist/create-admin.d.ts

@@ -0,0 +1,5 @@
+export declare const createAdminUser: (input: {
+    name: string;
+    email: string;
+    password: string;
+}) => Promise<void>;

package/dist/define.d.ts

@@ -0,0 +1,254 @@
+export type CollectionLabels = {
+    singular: string;
+    plural: string;
+};
+export type DatabaseConfig = {
+    dialect: "sqlite" | "postgres";
+    url?: string;
+};
+export type LocaleConfig = {
+    default: string;
+    supported: string[];
+};
+export type AdminFieldComponent = {
+    component?: string;
+    placeholder?: string;
+    position?: "content" | "sidebar";
+    rows?: number;
+    help?: string;
+    hidden?: boolean;
+};
+export type FieldCondition = {
+    field: string;
+    value: string | string[] | boolean;
+};
+type BaseFieldConfig<TType extends string, TValue = unknown> = {
+    type: TType;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: TValue;
+    indexed?: boolean;
+    unique?: boolean;
+    translatable?: boolean;
+    condition?: FieldCondition;
+    admin?: AdminFieldComponent;
+    access?: {
+        read?: (context: {
+            user?: {
+                id: string;
+                role?: string;
+                email?: string;
+            } | null;
+            doc?: Record<string, unknown> | null;
+            operation: string;
+            collection: string;
+        }) => boolean | Promise<boolean>;
+        update?: (context: {
+            user?: {
+                id: string;
+                role?: string;
+                email?: string;
+            } | null;
+            doc?: Record<string, unknown> | null;
+            operation: string;
+            collection: string;
+        }) => boolean | Promise<boolean>;
+    };
+};
+export type TextFieldConfig = BaseFieldConfig<"text", string> & {
+    maxLength?: number;
+};
+export type SlugFieldConfig = BaseFieldConfig<"slug", string> & {
+    from?: string;
+};
+export type EmailFieldConfig = BaseFieldConfig<"email", string>;
+export type NumberFieldConfig = BaseFieldConfig<"number", number>;
+export type BooleanFieldConfig = BaseFieldConfig<"boolean", boolean>;
+export type DateFieldConfig = BaseFieldConfig<"date", string>;
+export type SelectFieldConfig = BaseFieldConfig<"select", string> & {
+    options: string[];
+};
+export type RichTextNode = {
+    type: string;
+    value?: string;
+    level?: number;
+    children?: RichTextNode[];
+    [key: string]: unknown;
+};
+export type RichTextDocument = {
+    type: "root";
+    children: RichTextNode[];
+};
+export type RichTextFieldConfig = BaseFieldConfig<"richText", RichTextDocument>;
+export type ImageFieldConfig = BaseFieldConfig<"image", string>;
+export type RelationFieldConfig = BaseFieldConfig<"relation", string | string[]> & {
+    collection: string;
+    hasMany?: boolean;
+};
+export type ArrayFieldConfig = BaseFieldConfig<"array", unknown[]> & {
+    of: FieldConfig;
+};
+export type JsonFieldConfig = BaseFieldConfig<"json", unknown> & {
+    schema?: string;
+};
+export type BlocksFieldConfig = BaseFieldConfig<"blocks", Array<Record<string, unknown>>> & {
+    types: Record<string, Record<string, FieldConfig>>;
+};
+export type FieldConfig = TextFieldConfig | SlugFieldConfig | EmailFieldConfig | NumberFieldConfig | BooleanFieldConfig | DateFieldConfig | SelectFieldConfig | RichTextFieldConfig | ImageFieldConfig | RelationFieldConfig | ArrayFieldConfig | JsonFieldConfig | BlocksFieldConfig;
+export type CollectionFieldMap = Record<string, FieldConfig>;
+export type SeedDocument = Record<string, unknown>;
+export type CollectionViewConfig = {
+    list?: {
+        columns?: string[];
+        defaultSort?: {
+            field: string;
+            direction: "asc" | "desc";
+        };
+    };
+};
+export type CollectionConfig = {
+    slug: string;
+    labels: CollectionLabels;
+    labelField?: string;
+    pathPrefix?: string;
+    preview?: boolean | string;
+    timestamps?: boolean;
+    drafts?: boolean;
+    versions?: {
+        max: number;
+    };
+    auth?: boolean;
+    singleton?: boolean;
+    access?: CollectionAccess;
+    hooks?: CollectionHooks;
+    fields: CollectionFieldMap;
+    views?: CollectionViewConfig;
+    seed?: SeedDocument[];
+};
+export type AdminNavItem = {
+    label: string;
+    href: string;
+    icon?: string;
+    /** Sort order — lower values appear first (default: 0) */
+    weight?: number;
+};
+export type WebhookEvent = "create" | "update" | "delete" | "publish" | "unpublish";
+export type WebhookContext = {
+    user?: {
+        id: string;
+        role?: string;
+        email?: string;
+    } | null;
+    event: WebhookEvent;
+    collection: string;
+    timestamp: string;
+};
+export type WebhookConfig = {
+    /** Display name (shown in logs) */
+    name: string;
+    /** URL to POST to */
+    url: string;
+    /** Events that trigger this webhook */
+    events: WebhookEvent[];
+    /** Restrict to specific collections (omit for all) */
+    collections?: string[];
+    /** HTTP method (default: POST) */
+    method?: "POST" | "PUT" | "PATCH";
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Transform the payload (default: { event, collection, doc, user, timestamp }) */
+    payload?: (doc: Record<string, unknown>, context: WebhookContext) => any;
+};
+export type AdminUploadConfig = {
+    /** Allowed MIME types (default: images, PDF, video) */
+    allowedTypes?: string[];
+    /** Max file size in bytes (default: 50 MB) */
+    maxFileSize?: number;
+};
+export type AdminRateLimitConfig = {
+    /** Max login attempts before blocking (default: 5) */
+    maxAttempts?: number;
+    /** Time window in milliseconds (default: 15 minutes) */
+    windowMs?: number;
+};
+export type AdminConfig = {
+    dateFormat?: string;
+    nav?: AdminNavItem[];
+    uploads?: AdminUploadConfig;
+    rateLimit?: AdminRateLimitConfig;
+    /** Admin list page size (default: 20) */
+    pageSize?: number;
+    /** Webhooks fired on content events */
+    webhooks?: WebhookConfig[];
+};
+export type CMSConfig = {
+    database?: DatabaseConfig;
+    locales?: LocaleConfig;
+    admin?: AdminConfig;
+    collections: CollectionConfig[];
+};
+export type AccessContext = {
+    user?: {
+        id: string;
+        role?: string;
+        email?: string;
+    } | null;
+    doc?: Record<string, unknown> | null;
+    operation: string;
+    collection: string;
+};
+export type AccessRule = (context: AccessContext) => boolean | Promise<boolean>;
+export type CollectionAccess = Partial<Record<"read" | "create" | "update" | "delete" | "publish" | "schedule", AccessRule>>;
+export declare const hasRole: (...roles: string[]) => AccessRule;
+export type HookContext = {
+    user?: AccessContext["user"];
+    operation: string;
+    collection: string;
+    timestamp: string;
+    cache?: {
+        invalidate: (opts: {
+            tags: string[];
+        }) => void;
+    };
+};
+export type CollectionHooks = {
+    beforeCreate?: (data: Record<string, unknown>, context: HookContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    afterCreate?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+    beforeUpdate?: (data: Record<string, unknown>, existing: Record<string, unknown>, context: HookContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    afterUpdate?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+    beforeDelete?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+    afterDelete?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+    beforePublish?: (doc: Record<string, unknown>, context: HookContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    afterPublish?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+    beforeUnpublish?: (doc: Record<string, unknown>, context: HookContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    afterUnpublish?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+    beforeSchedule?: (doc: Record<string, unknown>, context: HookContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    afterSchedule?: (doc: Record<string, unknown>, context: HookContext) => void | Promise<void>;
+};
+export declare const fields: {
+    text: (options?: Omit<TextFieldConfig, "type">) => TextFieldConfig;
+    slug: (options?: Omit<SlugFieldConfig, "type">) => SlugFieldConfig;
+    email: (options?: Omit<EmailFieldConfig, "type">) => EmailFieldConfig;
+    number: (options?: Omit<NumberFieldConfig, "type">) => NumberFieldConfig;
+    boolean: (options?: Omit<BooleanFieldConfig, "type">) => BooleanFieldConfig;
+    date: (options?: Omit<DateFieldConfig, "type">) => DateFieldConfig;
+    select: (options: Omit<SelectFieldConfig, "type">) => SelectFieldConfig;
+    richText: (options?: Omit<RichTextFieldConfig, "type">) => RichTextFieldConfig;
+    image: (options?: Omit<ImageFieldConfig, "type">) => ImageFieldConfig;
+    relation: (options: Omit<RelationFieldConfig, "type">) => RelationFieldConfig;
+    array: (options: Omit<ArrayFieldConfig, "type">) => ArrayFieldConfig;
+    json: (options?: Omit<JsonFieldConfig, "type">) => JsonFieldConfig;
+    blocks: (options: Omit<BlocksFieldConfig, "type">) => BlocksFieldConfig;
+};
+export declare const defineCollection: (collection: CollectionConfig) => CollectionConfig;
+export declare const defineConfig: (config: CMSConfig) => CMSConfig;
+export declare const getCollectionMap: (config: CMSConfig) => {
+    [k: string]: CollectionConfig;
+};
+export declare const getDefaultLocale: (config: CMSConfig) => string;
+export declare const getTranslatableFieldNames: (collection: CollectionConfig) => string[];
+export declare const isStructuralField: (field: FieldConfig) => boolean;
+export declare const getCollectionLabel: (collection: CollectionConfig) => string;
+export declare const getLabelField: (collection: CollectionConfig) => string;
+export {};

package/dist/generator.d.ts

@@ -0,0 +1,9 @@
+import type { CMSConfig } from "./define";
+type GeneratorOptions = {
+    outputDir: string;
+    coreImportPath?: string;
+    runtimeImportPath?: string;
+    configImportPath?: string;
+};
+export declare const generate: (config: CMSConfig, options: GeneratorOptions) => Promise<void>;
+export {};

package/dist/image.d.ts

@@ -0,0 +1,9 @@
+declare const ALLOWED_FORMATS: readonly ["webp", "avif", "jpeg", "png"];
+type Format = (typeof ALLOWED_FORMATS)[number];
+export declare function cmsImage(src: string, width?: number, format?: Format): string;
+export declare function cmsSrcset(src: string, widths?: number[], format?: Format): string;
+export declare function transformImage(src: string, width?: number, format?: string, quality?: number): Promise<{
+    buffer: Buffer;
+    contentType: string;
+} | null>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export { configureCmsRuntime, resetCmsRuntime, getCmsRuntime, getDb, closeDb, getStorage, getEmail, readEnv, } from "./runtime";
+export type { CmsRuntimeConfig, CmsStorageAdapter, CmsEmailAdapter } from "./runtime";
+export { initSchema, getSchema, resetSchema } from "./schema";
+export { fields, defineCollection, defineConfig, getCollectionMap, getDefaultLocale, getTranslatableFieldNames, isStructuralField, getCollectionLabel, getLabelField, hasRole, } from "./define";
+export type { CMSConfig, CollectionConfig, CollectionFieldMap, FieldConfig, TextFieldConfig, SlugFieldConfig, EmailFieldConfig, NumberFieldConfig, BooleanFieldConfig, DateFieldConfig, SelectFieldConfig, RichTextFieldConfig, ImageFieldConfig, RelationFieldConfig, ArrayFieldConfig, JsonFieldConfig, BlocksFieldConfig, RichTextNode, RichTextDocument, CollectionLabels, DatabaseConfig, LocaleConfig, AdminConfig, AdminNavItem, WebhookConfig, WebhookEvent, WebhookContext, AdminFieldComponent, FieldCondition, SeedDocument, CollectionViewConfig, AccessContext, AccessRule, CollectionAccess, HookContext, CollectionHooks, } from "./define";
+export { createCms } from "./api";
+export type { FindOptions } from "./api";
+export type CustomFieldProps = {
+    name: string;
+    field: import("./define").FieldConfig;
+    value: string;
+    readOnly: boolean;
+};
+export { hashPassword, verifyPassword, createSession, validateSession, destroySession, getSessionUser, createInvite, validateInvite, consumeInvite, SESSION_COOKIE_NAME, setSessionCookie, clearSessionCookie, } from "./auth";
+export type { SessionUser } from "./auth";
+export { assets, folders } from "./assets";
+export type { AssetRecord, FolderRecord } from "./assets";
+export { parseBlocks, parseList, cacheTags } from "./content";
+export { renderRichText, createRichTextFromPlainText, richTextToPlainText } from "./richtext";
+export { cloneValue, slugify, escapeHtml, serializeFieldValue } from "./values";
+export { cmsImage, cmsSrcset, transformImage } from "./image";
+export { initDateFormat, formatDate, resolveAdminRoute, humanize, formatFieldValue, getListColumns, getFieldSets, } from "./admin";
+export type { AdminRoute } from "./admin";
+export { acquireLock, releaseLock } from "./locks";
+export { isAiEnabled, getAiModel, streamAltText, streamSeoDescription, streamTranslation } from "./ai";
+export { generate } from "./generator";
+export { seedDatabase } from "./seed";
+export { createAdminUser } from "./create-admin";

package/dist/integration.d.ts

@@ -0,0 +1,14 @@
+import type { AstroIntegration } from "astro";
+export interface CmsIntegrationOptions {
+    /** Path to the CMS config file (default: "src/cms/cms.config") */
+    configPath?: string;
+    /** Path to the CMS runtime file (default: "src/cms/runtime") */
+    runtimePath?: string;
+    /** Path to the generated output directory (default: "src/cms/.generated") */
+    generatedPath?: string;
+    /** Path to the adapters directory (default: "src/cms/adapters") */
+    adaptersPath?: string;
+    /** Path to the generator script (default: "src/cms/generator.ts") */
+    generatorPath?: string;
+}
+export default function cmsIntegration(options?: CmsIntegrationOptions): AstroIntegration;

package/dist/integration.js

@@ -64,7 +64,7 @@ export default function cmsIntegration(options) {
     return {
         name: "kide-cms",
         hooks: {
-            "astro:config:setup": ({ command, updateConfig, injectRoute, addMiddleware }) => {
+            "astro:config:setup": ({ command, updateConfig, injectRoute, injectScript, addMiddleware }) => {
                 const root = process.cwd();
                 // Generate a wrapper CSS that adds @source directives and imports user's admin CSS
                 const corePkgDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
@@ -193,7 +193,10 @@ export default function cmsIntegration(options) {
                 injectRoute({ pattern: "/admin/setup", entrypoint: "@kidecms/core/routes/pages/admin/setup.astro" });
                 injectRoute({ pattern: "/admin/invite", entrypoint: "@kidecms/core/routes/pages/admin/invite.astro" });
                 injectRoute({ pattern: "/admin/assets", entrypoint: "@kidecms/core/routes/pages/admin/assets/index.astro" });
-                injectRoute({ pattern: "/admin/assets/[id]", entrypoint: "@kidecms/core/routes/pages/admin/assets/[id].astro" });
+                injectRoute({
+                    pattern: "/admin/assets/[id]",
+                    entrypoint: "@kidecms/core/routes/pages/admin/assets/[id].astro",
+                });
                 injectRoute({ pattern: "/admin/[...path]", entrypoint: "@kidecms/core/routes/pages/admin/[...path].astro" });
                 // Inject API routes
                 injectRoute({ pattern: "/api/cms/auth/login", entrypoint: "@kidecms/core/routes/api/cms/auth/login.ts" });
@@ -201,7 +204,10 @@ export default function cmsIntegration(options) {
                 injectRoute({ pattern: "/api/cms/auth/setup", entrypoint: "@kidecms/core/routes/api/cms/auth/setup.ts" });
                 injectRoute({ pattern: "/api/cms/auth/invite", entrypoint: "@kidecms/core/routes/api/cms/auth/invite.ts" });
                 injectRoute({ pattern: "/api/cms/assets/upload", entrypoint: "@kidecms/core/routes/api/cms/assets/upload.ts" });
-                injectRoute({ pattern: "/api/cms/assets/folders", entrypoint: "@kidecms/core/routes/api/cms/assets/folders.ts" });
+                injectRoute({
+                    pattern: "/api/cms/assets/folders",
+                    entrypoint: "@kidecms/core/routes/api/cms/assets/folders.ts",
+                });
                 injectRoute({ pattern: "/api/cms/assets/[id]", entrypoint: "@kidecms/core/routes/api/cms/assets/[id].ts" });
                 injectRoute({ pattern: "/api/cms/assets", entrypoint: "@kidecms/core/routes/api/cms/assets/index.ts" });
                 injectRoute({ pattern: "/api/cms/ai/alt-text", entrypoint: "@kidecms/core/routes/api/cms/ai/alt-text.ts" });
@@ -215,7 +221,10 @@ export default function cmsIntegration(options) {
                 // Preview render route uses Astro Container API which depends on Vite internals.
                 // Only inject in dev mode — production builds (especially Cloudflare Workers) can't bundle it.
                 if (command === "dev") {
-                    injectRoute({ pattern: "/api/cms/preview/render", entrypoint: "@kidecms/core/routes/api/cms/preview/render.ts" });
+                    injectRoute({
+                        pattern: "/api/cms/preview/render",
+                        entrypoint: "@kidecms/core/routes/api/cms/preview/render.ts",
+                    });
                 }
                 injectRoute({
                     pattern: "/api/cms/references/[collection]/[id]",
@@ -228,6 +237,9 @@ export default function cmsIntegration(options) {
                 });
                 // Inject auth middleware
                 addMiddleware({ entrypoint: "@kidecms/core/middleware/auth.ts", order: "pre" });
+                // Inject live-preview client script (no-op unless ?preview is in the URL)
+                const previewClient = path.join(corePkgDir, "client", "preview.ts");
+                injectScript("page", `import ${JSON.stringify(previewClient)};`);
                 // Generate schema, types, validators, and API
                 console.log("  [cms] Generating schema, types, validators, and API...");
                 try {

package/dist/locks.d.ts

@@ -0,0 +1,7 @@
+export declare const acquireLock: (collection: string, documentId: string, userId: string, userEmail: string) => Promise<{
+    acquired: true;
+} | {
+    acquired: false;
+    userEmail: string;
+}>;
+export declare const releaseLock: (collection: string, documentId: string, userId: string) => Promise<void>;

package/dist/richtext.d.ts

@@ -0,0 +1 @@
+export { createRichTextFromPlainText, renderRichText, richTextToPlainText } from "./values";

package/dist/runtime.d.ts

@@ -0,0 +1,24 @@
+export type CmsStorageAdapter = {
+    putFile: (storagePath: string, data: ArrayBuffer | Uint8Array) => Promise<void>;
+    getFile: (storagePath: string) => Promise<ArrayBuffer | null>;
+    deleteFile: (storagePath: string) => Promise<void>;
+};
+export type CmsEmailAdapter = {
+    sendInviteEmail: (to: string, inviteUrl: string) => Promise<boolean>;
+    isEmailConfigured: () => boolean;
+};
+export type CmsRuntimeConfig = {
+    getDb: () => Promise<any>;
+    closeDb?: () => void;
+    storage: CmsStorageAdapter;
+    email?: CmsEmailAdapter;
+    env?: (key: string) => string | undefined;
+};
+export declare const configureCmsRuntime: (config: CmsRuntimeConfig) => void;
+export declare const resetCmsRuntime: () => void;
+export declare const getCmsRuntime: () => CmsRuntimeConfig;
+export declare const getDb: () => Promise<any>;
+export declare const closeDb: () => void;
+export declare const getStorage: () => CmsStorageAdapter;
+export declare const getEmail: () => CmsEmailAdapter;
+export declare const readEnv: (key: string) => string | undefined;

package/dist/schema.d.ts

@@ -0,0 +1,17 @@
+type SchemaModule = {
+    cmsTables: Record<string, {
+        main: any;
+        translations?: any;
+        versions?: any;
+    }>;
+    cmsAssets: any;
+    cmsAssetFolders: any;
+    cmsSessions: any;
+    cmsLocks: any;
+    cmsInvites: any;
+    [key: string]: any;
+};
+export declare const initSchema: (nextSchema: SchemaModule) => void;
+export declare const resetSchema: () => void;
+export declare const getSchema: () => SchemaModule;
+export {};

package/dist/seed.d.ts

@@ -0,0 +1,2 @@
+import type { CMSConfig, SeedDocument } from "./define";
+export declare const seedDatabase: (config: CMSConfig, seedData: Record<string, SeedDocument[]>) => Promise<void>;

package/dist/values.d.ts

@@ -0,0 +1,8 @@
+import type { FieldConfig, RichTextDocument } from "./define";
+export declare const cloneValue: <T>(value: T) => T;
+export declare const slugify: (value: string) => string;
+export declare const escapeHtml: (value: string) => string;
+export declare const createRichTextFromPlainText: (text: string) => RichTextDocument;
+export declare const renderRichText: (document?: RichTextDocument | null) => string;
+export declare const richTextToPlainText: (document?: RichTextDocument | null) => string;
+export declare const serializeFieldValue: (field: FieldConfig, value: unknown) => string;

package/dist/webhooks.d.ts

@@ -0,0 +1,2 @@
+import type { CMSConfig, WebhookContext, WebhookEvent } from "./define";
+export declare function dispatchWebhooks(config: CMSConfig, event: WebhookEvent, collectionSlug: string, doc: Record<string, unknown>, user: WebhookContext["user"]): Promise<void>;

package/dist/webhooks.js

@@ -61,7 +61,9 @@ export async function dispatchWebhooks(config, event, collectionSlug, doc, user)
     };
     // Fire all matching webhooks in parallel — don't block the operation
     for (const webhook of matching) {
-        const payload = webhook.payload ? webhook.payload(doc, context) : { event, collection: collectionSlug, doc, user, timestamp: context.timestamp };
+        const payload = webhook.payload
+            ? webhook.payload(doc, context)
+            : { event, collection: collectionSlug, doc, user, timestamp: context.timestamp };
         const body = JSON.stringify(payload);
         // Fire and forget — failures are logged but don't bubble up
         deliverWebhook(webhook, body).catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kidecms/core",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Code-first CMS framework built for Astro.",
   "author": "Matti Hernesniemi",
   "license": "MIT",

package/routes/pages/admin/[...path].astro

@@ -232,7 +232,10 @@ if (collection && collectionSlug && canAccessCurrent) {
     return Astro.redirect(`/admin/${collectionSlug}/${(await collectionApi.create({}, runtimeContext))._id}`);
   }
 
-  for (const [fieldName, field] of Object.entries(collection.fields) as [string, import("@kidecms/core").FieldConfig][]) {
+  for (const [fieldName, field] of Object.entries(collection.fields) as [
+    string,
+    import("@kidecms/core").FieldConfig,
+  ][]) {
     if (field.type === "relation" && canRead(field.collection)) {
       const relatedDocs = await cmsRuntime[field.collection].find(
         {

package/routes/pages/admin/assets/index.astro

@@ -47,7 +47,12 @@ const assetData = folderAssets.map((a) => ({
 }));
 ---
 
-<AdminLayout title="Assets | Kide CMS" collections={accessibleCollections} activeCollection="assets" customNav={config.admin?.nav}>
+<AdminLayout
+  title="Assets | Kide CMS"
+  collections={accessibleCollections}
+  activeCollection="assets"
+  customNav={config.admin?.nav}
+>
   <AssetsGrid
     client:load
     folders={folderData}