includio-cms 0.36.9 → 0.37.0

package/dist/core/cms.js

@@ -5,7 +5,6 @@ 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';
-import { applyVariantAttributeIndexes } from '../shop/server/init.js';
 export class CMS {
     config;
     databaseAdapter;
@@ -21,21 +20,15 @@ export class CMS {
     mediaConfig;
     typographyConfig;
     sidebarHelp;
-    shopConfig;
     cmpConfig;
     adminConfig;
-    /**
-     * Resolves once the shop's variant-attribute GIN indexes have been applied
-     * by `initCMS()`. `null` when the CMS is configured without a shop. Tests
-     * can `await` this to gate on init completion; production callers don't
-     * need to — index application is idempotent and non-blocking.
-     * @internal
-     */
-    shopInitPromise = null;
+    /** Per-module init promises (`serverHooks.init`), keyed by module id. @internal */
+    _moduleInitPromises = new Map();
     plugins = [];
     customFields = new Map();
     iconSets = new Map();
     apiKeys = [];
+    modules = new Map();
     constructor(config) {
         this.config = config;
         this.databaseAdapter = config.db;
@@ -46,9 +39,14 @@ export class CMS {
         this.mediaConfig = config.media || {};
         this.typographyConfig = config.typography || {};
         this.sidebarHelp = config.sidebarHelp ?? true;
-        this.shopConfig = config.shop ?? null;
         this.cmpConfig = config.cmp ?? null;
         this.adminConfig = config.admin ?? null;
+        for (const module of config.modules ?? []) {
+            if (this.modules.has(module.id)) {
+                throw new Error(`Duplicate module id: "${module.id}"`);
+            }
+            this.modules.set(module.id, module);
+        }
         this.collections = {};
         this.singles = {};
         this.forms = {};
@@ -170,6 +168,66 @@ export class CMS {
         }
         return form;
     }
+    getModule(id) {
+        return this.modules.get(id);
+    }
+    getModuleConfig(id) {
+        return this.modules.get(id)?.config;
+    }
+    hasModule(id) {
+        return this.modules.has(id);
+    }
+    /**
+     * Back-compat shim — the shop config now lives on the `shop` module
+     * (`defineConfig({ modules: [defineShop(...)] })`). Reads through the module
+     * registry so the entire shop server/http/remote layer keeps working unchanged.
+     */
+    get shopConfig() {
+        return this.getModuleConfig('shop') ?? null;
+    }
+    /**
+     * Resolves once the shop module's init (variant-attribute GIN indexes) has run.
+     * `null` when no shop module is configured. Idempotent; tests can `await` it.
+     * @internal
+     */
+    get shopInitPromise() {
+        return this._moduleInitPromises.get('shop') ?? null;
+    }
+    /**
+     * Runs each module's `serverHooks.init` (idempotent, non-blocking). Called by
+     * `initCMS`. Errors are logged, never thrown. @internal
+     */
+    runModuleInit() {
+        const drizzle = this.databaseAdapter._drizzle;
+        const first = this.languages[0];
+        const defaultLanguage = typeof first === 'string'
+            ? first
+            : first && typeof first === 'object' && 'code' in first
+                ? String(first.code)
+                : 'pl';
+        for (const module of this.modules.values()) {
+            const hooks = module.serverHooks;
+            if (!hooks)
+                continue;
+            const ctx = { drizzle, config: module.config, defaultLanguage };
+            const onError = (e) => console.warn(`[module:${module.id}] init failed:`, e);
+            let p = null;
+            if (hooks.init) {
+                p = Promise.resolve(hooks.init(ctx)).catch(onError);
+            }
+            else if (hooks.initModule) {
+                // Server-only: resolve the module's server entry from node_modules at
+                // runtime (a plain string in the module's client-safe barrel — no import
+                // there — so browser builds stay clean) and run its `serverInit`.
+                const specifier = hooks.initModule;
+                p = import(/* @vite-ignore */ specifier)
+                    .then((m) => m.serverInit?.(ctx))
+                    .catch(onError);
+            }
+            if (p)
+                this._moduleInitPromises.set(module.id, p);
+        }
+    }
 }
 let cms;
 export function initCMS(config) {
@@ -178,6 +236,9 @@ export function initCMS(config) {
     import('./server/media/operations/backgroundMaintenance.js')
         .then((m) => m.startBackgroundMaintenance())
         .catch((e) => console.warn('[cms] Failed to start background maintenance:', e));
+    // Run each registered module's server-side init (idempotent, non-blocking).
+    // Shop init applies variant-attribute GIN indexes + smoke-tests email templates.
+    cms.runModuleInit();
     // Start in-process media optimization worker (generuje warianty poza ścieżką renderu).
     // Wyłączalny przez media.optimization.worker = false.
     if (cms.mediaConfig.optimization?.worker !== false) {
@@ -185,29 +246,6 @@ export function initCMS(config) {
             .then((m) => m.startMediaOptimizationWorker())
             .catch((e) => console.warn('[cms] Failed to start media worker:', e));
     }
-    // Apply shop variantAttribute GIN indexes (idempotent CREATE INDEX IF NOT EXISTS).
-    // Pass shop + drizzle explicitly so the dynamic import doesn't depend on a
-    // shared CMS singleton (vitest can give the dynamic module a fresh instance).
-    if (cms.shopConfig) {
-        const drizzle = cms.databaseAdapter._drizzle;
-        if (drizzle) {
-            cms.shopInitPromise = applyVariantAttributeIndexes(cms.shopConfig, drizzle).catch((e) => {
-                console.warn('[shop] Failed to apply variant attribute indexes:', e);
-            });
-        }
-        // Smoke-test built-in shop email templates — fast lookup-only sweep.
-        // Catches corrupt installs (missing files in dist) at boot instead of
-        // at first email send. Dynamic import avoids loading shop server code
-        // when there is no shop configured.
-        import('../shop/server/email.js')
-            .then(({ REQUIRED_TEMPLATE_NAMES }) => import('../shop/server/emailTemplateRegistry.js').then(({ validateBuiltinTemplates }) => {
-            const defaultLang = cms.languages[0] ?? 'pl';
-            validateBuiltinTemplates([...REQUIRED_TEMPLATE_NAMES], defaultLang);
-        }))
-            .catch((e) => {
-            console.error('[shop] Built-in email template validation failed:', e);
-        });
-    }
     return cms;
 }
 /**

package/dist/core/config/validatePreviews.d.ts

@@ -0,0 +1,12 @@
+import type { CMSConfig } from '../../types/cms.js';
+/**
+ * Cross-field validation of preview views: Zod checks the shape, this checks the
+ * relationships it cannot see (`layout` is typed as `unknown` there).
+ *
+ * Runs from `defineConfig`, i.e. at dev-server start and at build time, so a
+ * typo in `tab.preview` fails the build instead of reaching production.
+ *
+ * @throws {ConfigValidationError} when any collection/single is inconsistent.
+ * @internal
+ */
+export declare function validatePreviews(config: CMSConfig): void;

package/dist/core/config/validatePreviews.js

@@ -0,0 +1,90 @@
+import { ConfigValidationError } from '../errors.js';
+/** Collect every `tab` node in a layout tree — tabs may sit inside sections/cards/columns/stacks. */
+function collectTabs(nodes) {
+    const out = [];
+    for (const node of nodes) {
+        if (node.type === 'tab')
+            out.push(node);
+        const children = node.children;
+        if (Array.isArray(children))
+            out.push(...collectTabs(children));
+    }
+    return out;
+}
+function tabLabel(tab) {
+    if (typeof tab.label === 'string')
+        return tab.label;
+    return Object.values(tab.label ?? {})[0] ?? '(unnamed tab)';
+}
+function checkOne(config, path, issues) {
+    const previews = config.previews;
+    if (previews && config.previewUrl) {
+        issues.push({
+            path: `${path}.previews`,
+            message: 'cannot declare both `previewUrl` and `previews`',
+            hint: 'keep `previewUrl` for a single preview, or move it into `previews[]` as one view'
+        });
+    }
+    if (previews && previews.length === 0) {
+        issues.push({
+            path: `${path}.previews`,
+            message: '`previews` must contain at least one view',
+            hint: 'remove the key, or declare a view: { name, url }'
+        });
+    }
+    const names = new Set();
+    let defaults = 0;
+    previews?.forEach((view, i) => {
+        if (names.has(view.name)) {
+            issues.push({
+                path: `${path}.previews[${i}].name`,
+                message: `duplicate preview view name '${view.name}'`,
+                hint: 'view names must be unique within a collection'
+            });
+        }
+        names.add(view.name);
+        if (view.default)
+            defaults++;
+    });
+    if (defaults > 1) {
+        issues.push({
+            path: `${path}.previews`,
+            message: `${defaults} views are marked as \`default\``,
+            hint: 'mark at most one view as default (otherwise the first one wins)'
+        });
+    }
+    const layout = config.layout;
+    if (!Array.isArray(layout))
+        return;
+    for (const tab of collectTabs(layout)) {
+        if (!tab.preview)
+            continue;
+        if (names.has(tab.preview))
+            continue;
+        const available = [...names];
+        issues.push({
+            path: `${path}.layout`,
+            message: `tab '${tabLabel(tab)}' references unknown preview view '${tab.preview}'`,
+            hint: available.length
+                ? `declared views: ${available.join(', ')}`
+                : 'this collection declares no `previews` — add them, or drop `preview` from the tab'
+        });
+    }
+}
+/**
+ * Cross-field validation of preview views: Zod checks the shape, this checks the
+ * relationships it cannot see (`layout` is typed as `unknown` there).
+ *
+ * Runs from `defineConfig`, i.e. at dev-server start and at build time, so a
+ * typo in `tab.preview` fails the build instead of reaching production.
+ *
+ * @throws {ConfigValidationError} when any collection/single is inconsistent.
+ * @internal
+ */
+export function validatePreviews(config) {
+    const issues = [];
+    config.collections?.forEach((c, i) => checkOne(c, `collections[${i}]`, issues));
+    config.singles?.forEach((s, i) => checkOne(s, `singles[${i}]`, issues));
+    if (issues.length)
+        throw new ConfigValidationError(issues);
+}

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

@@ -2,7 +2,15 @@
 export declare function resolveSlugPath(slugField: string | undefined): string;
 /** @internal Traverse dot-path; handles string & localized { lang: string }. */
 export declare function getSlugFromEntryData(data: Record<string, unknown>, slugPath: string, language?: string): string | undefined;
-/** @internal Pure: apply pathTemplate (no getCMS). */
+/**
+ * @internal Pure: apply pathTemplate (no getCMS).
+ *
+ * Always yields a root-relative path with exactly one leading slash — the
+ * contract the docs describe (`'blog/{slug}'` → `/blog/my-post`). Both the
+ * template and the slug may carry their own leading slash, so they are joined
+ * without doubling: neither the admin list (which used to print `//blog/x`) nor
+ * a consumer `href` (which used to get a *relative* `blog/x`) has to patch it.
+ */
 export declare function applyPathTemplate(pathTemplate: string | undefined, slug: string): string;
 /** @internal Compose full entry URL; undefined when no resolvable slug. */
 export declare function resolveEntryUrl(opts: {

package/dist/core/fields/slugPath.js

@@ -19,9 +19,23 @@ export function getSlugFromEntryData(data, slugPath, language) {
     }
     return undefined;
 }
-/** @internal Pure: apply pathTemplate (no getCMS). */
+/** Absolute URL with a scheme (`https://…`) — not a site path, leave it alone. */
+const ABSOLUTE_URL_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+/**
+ * @internal Pure: apply pathTemplate (no getCMS).
+ *
+ * Always yields a root-relative path with exactly one leading slash — the
+ * contract the docs describe (`'blog/{slug}'` → `/blog/my-post`). Both the
+ * template and the slug may carry their own leading slash, so they are joined
+ * without doubling: neither the admin list (which used to print `//blog/x`) nor
+ * a consumer `href` (which used to get a *relative* `blog/x`) has to patch it.
+ */
 export function applyPathTemplate(pathTemplate, slug) {
-    return pathTemplate ? pathTemplate.replace('{slug}', slug) : slug;
+    const raw = pathTemplate ? pathTemplate.replace('{slug}', slug) : slug;
+    if (ABSOLUTE_URL_RE.test(raw))
+        return raw;
+    const collapsed = raw.replace(/\/{2,}/g, '/');
+    return collapsed.startsWith('/') ? collapsed : `/${collapsed}`;
 }
 /** @internal Compose full entry URL; undefined when no resolvable slug. */
 export function resolveEntryUrl(opts) {

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

@@ -1,4 +1,13 @@
-import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
+import type { EntryData, PopulatedEntryData, DbEntryVersion } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+import type { PopulateCtx, ResolveStatus } from '../entries/operations/resolveEntry.js';
+/**
+ * Version of a *related* entry to populate. Exported for tests.
+ *
+ * `draft` falls back to the published version: a related entry that has never been
+ * drafted (only published versions) must still resolve, otherwise draft previews
+ * silently drop every relation to `null` — see preview.remote.ts, which populates
+ * form data with `status: 'draft'`.
+ */
+export declare function pickVersion(versions: DbEntryVersion[], status: ResolveStatus): DbEntryVersion | null;
 export declare function resolveRelationFields(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

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

@@ -2,14 +2,23 @@ import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap
 import { getCMS } from '../../cms.js';
 import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
-function pickVersion(versions, status) {
+/**
+ * Version of a *related* entry to populate. Exported for tests.
+ *
+ * `draft` falls back to the published version: a related entry that has never been
+ * drafted (only published versions) must still resolve, otherwise draft previews
+ * silently drop every relation to `null` — see preview.remote.ts, which populates
+ * form data with `status: 'draft'`.
+ */
+export function pickVersion(versions, status) {
     const sorted = versions.slice().sort((a, b) => b.versionNumber - a.versionNumber);
     const now = new Date();
+    const published = () => sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) ?? null;
     switch (status) {
         case 'published':
-            return sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) ?? null;
+            return published();
         case 'draft':
-            return sorted.find((v) => v.publishedAt == null) ?? null;
+            return sorted.find((v) => v.publishedAt == null) ?? published();
         case 'scheduled':
             return sorted.find((v) => v.publishedAt != null && v.publishedAt > now) ?? null;
     }

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

@@ -276,9 +276,12 @@ function generateDrizzleSchema(config) {
     code += `// Point your drizzle.config.ts schema field at this file.\n\n`;
     code += `export * from 'includio-cms/db-postgres/schema-core';\n`;
     code += `export * from 'includio-cms/auth-schema';\n`;
-    if (config.shop) {
+    if (config.modules?.some((m) => m.id === 'shop')) {
         code += `export * from 'includio-cms/db-postgres/schema-shop';\n`;
     }
+    if (config.modules?.some((m) => m.id === 'booking')) {
+        code += `export * from 'includio-cms/db-postgres/schema-booking';\n`;
+    }
     writeIfChanged(filePath, code);
 }
 function generateRemote(config) {
@@ -313,7 +316,9 @@ export function generateRuntime(config) {
         }
     }
     setGeneratorCustomFields(customFields);
-    setGeneratorShopVariantAttributes(config.shop?.variantAttributes ?? {});
+    const shopModule = config.modules?.find((m) => m.id === 'shop');
+    const shopConfig = shopModule?.config;
+    setGeneratorShopVariantAttributes(shopConfig?.variantAttributes ?? {});
     createCmsRuntimeDir();
     generateTypes(config);
     generateAPI(config);

package/dist/db-postgres/schema/booking/bookingAdjustments.d.ts

@@ -0,0 +1,186 @@
+import type { AdjustmentKind } from '../../../booking/adjustments.js';
+/**
+ * Manual staff adjustments to a booking's price (surcharge / negotiated
+ * discount). Append-only with soft-void (`voidedAt`) for audit. `amount` is
+ * signed minor units (surcharge > 0, discount < 0). Kept separate from
+ * rule-engine discounts so a recompute never clears them.
+ */
+export declare const bookingAdjustmentsTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "booking_adjustments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bookingId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "booking_id";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "kind";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgText";
+            data: AdjustmentKind;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: AdjustmentKind;
+        }>;
+        amount: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "amount";
+            tableName: "booking_adjustments";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "label";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reason: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "reason";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_by";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_at";
+            tableName: "booking_adjustments";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        voidedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "voided_at";
+            tableName: "booking_adjustments";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        voidedBy: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "voided_by";
+            tableName: "booking_adjustments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/db-postgres/schema/booking/bookingAdjustments.js

@@ -0,0 +1,22 @@
+import { integer, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { bookingsTable } from './bookings.js';
+/**
+ * Manual staff adjustments to a booking's price (surcharge / negotiated
+ * discount). Append-only with soft-void (`voidedAt`) for audit. `amount` is
+ * signed minor units (surcharge > 0, discount < 0). Kept separate from
+ * rule-engine discounts so a recompute never clears them.
+ */
+export const bookingAdjustmentsTable = pgTable('booking_adjustments', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    bookingId: uuid('booking_id')
+        .notNull()
+        .references(() => bookingsTable.id, { onDelete: 'cascade' }),
+    kind: text('kind').$type().notNull(),
+    amount: integer('amount').notNull(),
+    label: text('label').notNull(),
+    reason: text('reason'),
+    createdBy: text('created_by').notNull().default('staff'),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    voidedAt: timestamp('voided_at', { withTimezone: true }),
+    voidedBy: text('voided_by')
+});