includio-cms 0.6.2 → 0.7.1

package/dist/core/cms.js

@@ -1,23 +1,31 @@
+import { setSchemaGetCMS } from './fields/fieldSchemaToTs.js';
+import { betterAuth } from 'better-auth';
+import { drizzleAdapter } from 'better-auth/adapters/drizzle';
+import { admin } from 'better-auth/plugins';
+import { resetPasswordEmailTemplate } from '../admin/email/reset-password-template.js';
+import * as authSchema from '../server/db/schema/auth-schema.js';
 export class CMS {
     config;
     databaseAdapter;
     filesAdapter;
     emailAdapter;
-    auth;
+    authConfig;
     aiAdapter = null;
+    _betterAuth = null;
     collections;
     singles;
     forms;
     languages;
     mediaConfig;
     plugins = [];
+    customFields = new Map();
     apiKeys = [];
     constructor(config) {
         this.config = config;
         this.databaseAdapter = config.db;
         this.filesAdapter = config.files;
         this.emailAdapter = config.email ?? null;
-        this.auth = config.auth ?? null;
+        this.authConfig = config.auth ?? null;
         this.aiAdapter = config.ai || null;
         this.mediaConfig = config.media || {};
         this.collections = {};
@@ -44,7 +52,49 @@ export class CMS {
         this.apiKeys = config.apiKeys || [];
         if (config.plugins) {
             this.plugins = config.plugins;
+            for (const plugin of this.plugins) {
+                for (const def of plugin.fields ?? []) {
+                    if (this.customFields.has(def.fieldType)) {
+                        throw new Error(`Duplicate custom field type: "${def.fieldType}" (plugin: "${plugin.slug}")`);
+                    }
+                    this.customFields.set(def.fieldType, def);
+                }
+            }
         }
+        setSchemaGetCMS(() => this);
+    }
+    get auth() {
+        if (!this._betterAuth) {
+            if (!this.authConfig) {
+                throw new Error('Auth not configured. Add `auth` to your CMS config.');
+            }
+            const drizzleDb = this.databaseAdapter._drizzle;
+            if (!drizzleDb) {
+                throw new Error('Database adapter does not expose a drizzle instance (_drizzle).');
+            }
+            const emailAdapter = this.emailAdapter;
+            this._betterAuth = betterAuth({
+                database: drizzleAdapter(drizzleDb, { provider: 'pg', schema: authSchema }),
+                secret: this.authConfig.secret,
+                baseURL: this.authConfig.baseURL,
+                emailAndPassword: {
+                    enabled: true,
+                    async sendResetPassword({ user, url }, request) {
+                        if (!emailAdapter) {
+                            throw new Error('Email adapter not configured');
+                        }
+                        const lang = request?.headers.get('Accept-Language')?.startsWith('pl') ? 'pl' : 'en';
+                        const { subject, html } = resetPasswordEmailTemplate({
+                            resetUrl: url,
+                            lang
+                        });
+                        await emailAdapter.sendMail({ to: [user.email], subject, html });
+                    }
+                },
+                plugins: [admin()]
+            });
+        }
+        return this._betterAuth;
     }
     getBySlug(slug) {
         const config = this.collections[slug] || this.singles[slug];

package/dist/core/fields/fieldSchemaToTs.d.ts

@@ -1,5 +1,16 @@
 import type { Field } from '../../types/fields.js';
+import type { CustomFieldDefinition } from '../../types/plugins.js';
 import { z } from 'zod';
+/**
+ * Set custom fields map for client-side use (where getCMS() is unavailable).
+ */
+export declare function setSchemaCustomFields(customFields: Map<string, CustomFieldDefinition>): void;
+/**
+ * Set CMS getter for server-side use (avoids static import of server-only cms.ts).
+ */
+export declare function setSchemaGetCMS(getter: () => {
+    customFields: Map<string, CustomFieldDefinition>;
+}): void;
 type AnyZodObject = z.ZodObject<any, any>;
 interface GenerateZodSchemaOptions {
     parentRequired?: boolean;

package/dist/core/fields/fieldSchemaToTs.js

@@ -1,4 +1,28 @@
 import { z } from 'zod';
+let _customFieldsOverride = null;
+/**
+ * Set custom fields map for client-side use (where getCMS() is unavailable).
+ */
+export function setSchemaCustomFields(customFields) {
+    _customFieldsOverride = customFields;
+}
+let _getCMS = null;
+/**
+ * Set CMS getter for server-side use (avoids static import of server-only cms.ts).
+ */
+export function setSchemaGetCMS(getter) {
+    _getCMS = getter;
+}
+function getCustomFieldDef(fieldType) {
+    if (_customFieldsOverride)
+        return _customFieldsOverride.get(fieldType);
+    try {
+        return _getCMS?.().customFields.get(fieldType);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function generateZodSchemaFromField(field, languages, options = {
     parentRequired: true
 }) {
@@ -283,6 +307,12 @@ export function generateZodSchemaFromField(field, languages, options = {
             }
             return schema;
         }
+        case 'custom': {
+            const customDef = getCustomFieldDef(field.fieldType);
+            if (!customDef)
+                return z.any();
+            return customDef.zodSchema(field, languages);
+        }
         default:
             return z.any();
     }

package/dist/core/index.d.ts

@@ -1 +1,2 @@
 export { getCMS } from './cms.js';
+export { resolveMediaWithStyles, type ResolvedMedia } from './server/fields/utils/resolveMedia.js';

package/dist/core/index.js

@@ -1 +1,2 @@
 export { getCMS } from './cms.js';
+export { resolveMediaWithStyles } from './server/fields/utils/resolveMedia.js';

package/dist/core/server/fields/populateEntry.js

@@ -4,6 +4,7 @@ import { resolveMediaFields } from './resolveImageFields.js';
 import { resolveRelationFields } from './resolveRelationFields.js';
 import { resolveRichtextLinks } from './resolveRichtextLinks.js';
 import { resolveUrlFields } from './resolveUrlFields.js';
+import { getCMS } from '../../cms.js';
 function translateInlineBlockData(data, fields, language) {
     for (const field of fields) {
         const val = data[field.slug];
@@ -45,11 +46,60 @@ function translateInlineBlockData(data, fields, language) {
         }
     }
 }
+async function resolveCustomFields(data, fields) {
+    // Check if any custom fields exist before accessing CMS
+    const hasCustom = fields.some((f) => f.type === 'custom' ||
+        f.type === 'object' ||
+        f.type === 'blocks');
+    if (!hasCustom)
+        return data;
+    let cms;
+    try {
+        cms = getCMS();
+    }
+    catch {
+        return data;
+    }
+    const result = { ...data };
+    for (const field of fields) {
+        const val = data[field.slug];
+        switch (field.type) {
+            case 'custom': {
+                const def = cms.customFields.get(field.fieldType);
+                if (def?.populateResolver && val != null) {
+                    result[field.slug] = await def.populateResolver(val, field);
+                }
+                break;
+            }
+            case 'object':
+                if (val && typeof val === 'object' && 'data' in val) {
+                    result[field.slug] = {
+                        ...val,
+                        data: await resolveCustomFields(val.data, field.fields)
+                    };
+                }
+                break;
+            case 'blocks':
+                if (Array.isArray(val)) {
+                    result[field.slug] = await Promise.all(val.map(async (item) => {
+                        const blockDef = field.of.find((d) => d.slug === item.slug);
+                        if (blockDef) {
+                            return { ...item, data: await resolveCustomFields(item.data, blockDef.fields) };
+                        }
+                        return item;
+                    }));
+                }
+                break;
+        }
+    }
+    return result;
+}
 export async function populateEntryData(data, fields, language) {
     let populatedData = await resolveRelationFields(data, fields, language);
     populatedData = await resolveUrlFields(populatedData, fields, language);
     populatedData = await resolveMediaFields(populatedData, fields);
     populatedData = await resolveRichtextLinks(populatedData, fields, language);
+    populatedData = (await resolveCustomFields(populatedData, fields));
     populatedData = translateObject(populatedData, language);
     translateInlineBlockData(populatedData, fields, language);
     return populatedData;

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -1,6 +1,6 @@
 import { getCMS } from '../../cms.js';
 import { extractEntryIds as extractEntryIdsFromDoc, extractMediaIds as extractMediaIdsFromDoc, cloneDoc, walkLinkMarks, walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
-import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
+import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
 const ENTRY_ID_RE = /data-entry-id="([0-9a-f-]{36})"/g;
 function extractEntryIds(html) {
     const ids = [];
@@ -130,7 +130,8 @@ export async function resolveRichtextLinks(data, fields, language) {
         const slugPath = configSlug ? getEntrySlugPath(configSlug) : 'seo.slug';
         const slug = getSlugFromEntryData(rawData, slugPath, language);
         if (slug) {
-            slugMap[version.entryId] = slug;
+            const configSlug = entryConfigSlugMap[version.entryId];
+            slugMap[version.entryId] = configSlug ? getEntryPath(configSlug, slug) : slug;
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/core/server/fields/resolveUrlFields.js

@@ -1,7 +1,7 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
 import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 import { getDbEntries, getDbEntryVersions } from '../entries/operations/get.js';
-import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
+import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
 import { isExternalUrl, mergeRel } from '../../fields/urlUtils.js';
 const FLAT_KEY = '_flat';
 /**
@@ -121,7 +121,7 @@ export async function resolveUrlFields(data, fields, language) {
                 const slugPath = getEntrySlugPath(entry.slug);
                 const slug = getSlugFromEntryData(version.data, slugPath, language);
                 if (slug)
-                    slugMap[entry.id] = slug;
+                    slugMap[entry.id] = getEntryPath(entry.slug, slug);
             }
         }
     }

package/dist/core/server/fields/slugResolver.d.ts

@@ -8,3 +8,8 @@ export declare function getEntrySlugPath(configSlug: string): string;
  * Handles both plain strings and localized objects { lang: string }.
  */
 export declare function getSlugFromEntryData(data: Record<string, unknown>, slugPath: string, language?: string): string | undefined;
+/**
+ * Build full entry path using collection's pathTemplate.
+ * If no template configured, returns the raw slug.
+ */
+export declare function getEntryPath(configSlug: string, slug: string): string;

package/dist/core/server/fields/slugResolver.js

@@ -32,3 +32,19 @@ export function getSlugFromEntryData(data, slugPath, language) {
     }
     return undefined;
 }
+/**
+ * Build full entry path using collection's pathTemplate.
+ * If no template configured, returns the raw slug.
+ */
+export function getEntryPath(configSlug, slug) {
+    try {
+        const config = getCMS().getBySlug(configSlug);
+        if (config.pathTemplate) {
+            return config.pathTemplate.replace('{slug}', slug);
+        }
+    }
+    catch {
+        // Config not found — fall through
+    }
+    return slug;
+}

package/dist/core/server/fields/utils/resolveMedia.d.ts

@@ -0,0 +1,12 @@
+import type { ImageFieldStyle } from '../../../../types/fields.js';
+import type { ImageStyle, MediaFile } from '../../../../types/media.js';
+export interface ResolvedMedia {
+    data: MediaFile;
+    styles: Record<string, ImageStyle>;
+    blurDataUrl: string | null;
+}
+/**
+ * Resolve media files by IDs and generate image styles.
+ * Useful for plugins that need to resolve media references (e.g. photo-grid).
+ */
+export declare function resolveMediaWithStyles(mediaIds: string[], styles?: ImageFieldStyle[]): Promise<Record<string, ResolvedMedia>>;

package/dist/core/server/fields/utils/resolveMedia.js

@@ -0,0 +1,23 @@
+import { getCMS } from '../../../cms.js';
+import { getImageStyles } from './imageStyles.js';
+/**
+ * Resolve media files by IDs and generate image styles.
+ * Useful for plugins that need to resolve media references (e.g. photo-grid).
+ */
+export async function resolveMediaWithStyles(mediaIds, styles) {
+    if (!mediaIds.length)
+        return {};
+    const cms = getCMS();
+    const files = await cms.databaseAdapter.getMediaFiles({ data: { ids: mediaIds } });
+    // Synthetic ImageField to pass to getImageStyles
+    const syntheticField = {
+        type: 'image',
+        slug: '_resolved',
+        styles: styles ?? []
+    };
+    const entries = await Promise.all(files.map(async (file) => {
+        const { styles: resolvedStyles, blurDataUrl } = await getImageStyles(syntheticField, file);
+        return [file.id, { data: file, styles: resolvedStyles, blurDataUrl }];
+    }));
+    return Object.fromEntries(entries);
+}

package/dist/core/server/generator/fields.d.ts

@@ -1,2 +1,4 @@
 import type { Field } from '../../../types/fields.js';
+import type { CustomFieldDefinition } from '../../../types/plugins.js';
+export declare function setGeneratorCustomFields(customFields: Map<string, CustomFieldDefinition>): void;
 export declare function generateTsTypeFromFields(fields: Field[]): string;

package/dist/core/server/generator/fields.js

@@ -1,4 +1,8 @@
 import { toPascalCase } from './utils.js';
+let _customFields = new Map();
+export function setGeneratorCustomFields(customFields) {
+    _customFields = customFields;
+}
 function getFieldTypeAsString(field) {
     switch (field.type) {
         case 'text':
@@ -82,6 +86,10 @@ function getFieldTypeAsString(field) {
                 urlParts.push('newTab?: boolean');
             return `{ ${urlParts.join('; ')} }`;
         }
+        case 'custom': {
+            const customDef = _customFields.get(field.fieldType);
+            return customDef?.tsType ?? 'unknown';
+        }
         default:
             return 'any';
     }

package/dist/core/server/generator/generator.js

@@ -1,6 +1,6 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { generateTsTypeFromFields } from './fields.js';
+import { generateTsTypeFromFields, setGeneratorCustomFields } from './fields.js';
 import { generateTsTypeFromFormFields } from './formFields.js';
 import { generateZodSchemaStringFromFormFieldsAsString } from './formFieldSchemaToString.js';
 import { toPascalCase } from './utils.js';
@@ -203,6 +203,14 @@ function generateRemote(config) {
     writeFileSync(filePath, code);
 }
 export function generateRuntime(config) {
+    // Build custom fields map from plugins for type generation
+    const customFields = new Map();
+    for (const plugin of config.plugins ?? []) {
+        for (const field of plugin.fields ?? []) {
+            customFields.set(field.fieldType, field);
+        }
+    }
+    setGeneratorCustomFields(customFields);
     createCmsRuntimeDir();
     generateTypes(config);
     generateAPI(config);

package/dist/db-postgres/index.d.ts

@@ -1,3 +1,8 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
 import type { Config } from './types.js';
+import * as schema from './schema/index.js';
 import type { DatabaseAdapter } from '../types/adapters/db.js';
-export declare function pg(config: Config): DatabaseAdapter;
+export type DatabaseAdapterWithDrizzle = DatabaseAdapter & {
+    _drizzle: ReturnType<typeof drizzle<typeof schema>>;
+};
+export declare function pg(config: Config): DatabaseAdapterWithDrizzle;

package/dist/db-postgres/index.js

@@ -88,6 +88,7 @@ export function pg(config) {
     const client = postgres(config.databaseUrl);
     const db = drizzle(client, { schema });
     return {
+        _drizzle: db,
         createEntry: async (data) => {
             return db.transaction(async (tx) => {
                 const [newEntry] = await tx.insert(schema.entriesTable).values(data).returning();