fimo 0.17.0 → 0.18.0

package/dist/runtime/shared/preview-location.js

@@ -1,93 +1,5 @@
-const PREVIEW_INTERNAL_QUERY_PARAMS = new Set(['bl_preview_token', 'preview_token', 't']);
-const PREVIEW_PARENT_ORIGIN_STORAGE_KEY = 'fimo-preview-parent-origin';
-let rememberedPreviewParentOrigin;
-const getOrigin = (value) => {
-    if (!value) {
-        return null;
-    }
-    try {
-        const origin = new URL(value).origin;
-        return origin === 'null' ? null : origin;
-    }
-    catch {
-        return null;
-    }
-};
-/** Prefer the immediate embedding document over a potentially stale referrer. */
-export function resolvePreviewParentOrigin(referrer, ancestorOrigins) {
-    return getOrigin(ancestorOrigins?.[0]) ?? getOrigin(referrer);
-}
-/** Resolve and remember the trusted Studio origin across full-page navigation. */
-export function getPreviewParentOrigin(browser) {
-    const browserWindow = browser?.window ?? (typeof window === 'undefined' ? undefined : window);
-    const browserDocument = browser?.document ?? (typeof document === 'undefined' ? undefined : document);
-    if (!browserWindow) {
-        return null;
-    }
-    const storage = readSessionStorage(browserWindow);
-    const ancestorOrigin = getOrigin(browserWindow.location.ancestorOrigins?.[0]);
-    if (ancestorOrigin) {
-        rememberPreviewParentOrigin(ancestorOrigin, storage);
-        return ancestorOrigin;
-    }
-    const rememberedOrigin = readRememberedPreviewParentOrigin(storage);
-    if (rememberedOrigin) {
-        return rememberedOrigin;
-    }
-    const referrerOrigin = getOrigin(browserDocument?.referrer);
-    if (referrerOrigin) {
-        rememberPreviewParentOrigin(referrerOrigin, storage);
-    }
-    return referrerOrigin;
-}
-function readSessionStorage(browserWindow) {
-    try {
-        return browserWindow.sessionStorage;
-    }
-    catch {
-        return undefined;
-    }
-}
-function readRememberedPreviewParentOrigin(storage) {
-    if (rememberedPreviewParentOrigin !== undefined) {
-        return rememberedPreviewParentOrigin;
-    }
-    if (!storage) {
-        rememberedPreviewParentOrigin = null;
-        return null;
-    }
-    try {
-        rememberedPreviewParentOrigin = getOrigin(storage.getItem(PREVIEW_PARENT_ORIGIN_STORAGE_KEY) ?? undefined);
-    }
-    catch {
-        rememberedPreviewParentOrigin = null;
-    }
-    return rememberedPreviewParentOrigin;
-}
-function rememberPreviewParentOrigin(origin, storage) {
-    rememberedPreviewParentOrigin = origin;
-    if (!storage) {
-        return;
-    }
-    try {
-        storage.setItem(PREVIEW_PARENT_ORIGIN_STORAGE_KEY, origin);
-    }
-    catch {
-        // Storage availability must not block the preview message channel.
-    }
-}
-/** Keep sandbox credentials and the iframe cache-buster out of app navigation state. */
-export function getPreviewLocationPath(location) {
-    const search = new URLSearchParams(location.search ?? '');
-    for (const key of PREVIEW_INTERNAL_QUERY_PARAMS) {
-        search.delete(key);
-    }
-    const query = search.toString();
-    return `${location.pathname}${query ? `?${query}` : ''}${location.hash ?? ''}`;
-}
-export function getPreviewLocationChange(location) {
-    return {
-        path: location.pathname,
-        navigationPath: getPreviewLocationPath(location),
-    };
-}
+// The SvelteKit bundle reaches the preview location contract through this
+// path. Only one implementation may exist: the remembered parent origin is
+// module state, and a second copy would let the two bridges disagree about
+// which Studio origin is trusted.
+export * from '../preview/location.js';

package/dist/runtime/sveltekit/preview.d.ts

@@ -3,11 +3,20 @@ export interface PreviewNavigation {
     goto: (to: string) => unknown;
     /** SvelteKit `invalidateAll` — reruns every `load` against fresh content. */
     invalidateAll: () => Promise<unknown>;
+    /** Optional app-owned locale resolver, evaluated for every bridge message. */
+    locale?: () => string | undefined;
 }
 /** Load the platform preview script once. Empty configuration keeps preview disabled. */
 export declare function ensurePreviewScript(src: string | undefined): boolean;
-/** Report where the app is now. Studio keeps its URL and route selector in sync from this. */
-export declare function sendPreviewLocation(): void;
+/**
+ * Report where the app is now, and in which locale. Studio keeps its URL,
+ * route selector and content locale in sync from this.
+ *
+ * `locale` defaults to the locale the SvelteKit shell rendered into
+ * `<html lang>`; pass one explicitly when the app resolves it somewhere the
+ * document does not show, for example a cookie or a user preference.
+ */
+export declare function sendPreviewLocation(locale?: string): void;
 /**
  * Listen for the live Studio preview protocol and answer it with SvelteKit's
  * own navigation APIs. Returns the disconnect function.
@@ -15,5 +24,5 @@ export declare function sendPreviewLocation(): void;
  * Only messages from the established parent origin are honored. History stays
  * native, so Studio's back/forward controls need no protocol of their own.
  */
-export declare function connectPreview({ goto, invalidateAll }: PreviewNavigation): () => void;
+export declare function connectPreview({ goto, invalidateAll, locale }: PreviewNavigation): () => void;
 //# sourceMappingURL=preview.d.ts.map

package/dist/runtime/sveltekit/preview.js

@@ -1,4 +1,4 @@
-import { getPreviewLocationChange, getPreviewParentOrigin } from '../shared/preview-location.js';
+import { getDocumentLocale, getPreviewLocationChange, getPreviewParentOrigin } from '../shared/preview-location.js';
 /** Load the platform preview script once. Empty configuration keeps preview disabled. */
 export function ensurePreviewScript(src) {
     if (!src) {
@@ -13,14 +13,19 @@ export function ensurePreviewScript(src) {
     }
     return true;
 }
-/** Report where the app is now. Studio keeps its URL and route selector in sync from this. */
-export function sendPreviewLocation() {
+/**
+ * Report where the app is now, and in which locale. Studio keeps its URL,
+ * route selector and content locale in sync from this.
+ *
+ * `locale` defaults to the locale the SvelteKit shell rendered into
+ * `<html lang>`; pass one explicitly when the app resolves it somewhere the
+ * document does not show, for example a cookie or a user preference.
+ */
+export function sendPreviewLocation(locale) {
     const parentOrigin = getPreviewParentOrigin();
-    const locationChange = getPreviewLocationChange(window.location);
     window.parent.postMessage({
         type: 'nav/locationChange',
-        // Query and hash state only travels to an established parent origin.
-        payload: parentOrigin ? locationChange : { path: locationChange.path },
+        payload: getPreviewLocationChange(window.location, locale ?? getDocumentLocale(document, 'en'), parentOrigin),
     }, parentOrigin ?? '*');
 }
 /** Reliable-delivery reply: the parent retries an unacknowledged message forever. */
@@ -48,7 +53,7 @@ async function refreshContent(message, invalidateAll) {
  * Only messages from the established parent origin are honored. History stays
  * native, so Studio's back/forward controls need no protocol of their own.
  */
-export function connectPreview({ goto, invalidateAll }) {
+export function connectPreview({ goto, invalidateAll, locale }) {
     const onMessage = (event) => {
         const parentOrigin = getPreviewParentOrigin();
         if (event.source !== window.parent || !parentOrigin || event.origin !== parentOrigin) {
@@ -63,7 +68,7 @@ export function connectPreview({ goto, invalidateAll }) {
                 return;
             case 'nav/read-routes':
                 // The app owns its route table; answer with where it actually is.
-                sendPreviewLocation();
+                sendPreviewLocation(locale?.());
                 return;
             case 'content/refresh':
                 void refreshContent(message, invalidateAll);

package/dist/scripts/sync-forms.js

@@ -41,7 +41,7 @@ function frameworkFormsTarget(framework) {
         return 'next';
     if (framework === 'astro')
         return 'astro';
-    if (framework === 'sveltekit' || framework === 'sveltekit-1')
+    if (framework === 'sveltekit')
         return 'sveltekit';
     return null;
 }

package/dist/scripts/sync-schemas.js

@@ -120,10 +120,7 @@ function contentRuntimeImportFor(framework) {
     if (framework === 'astro') {
         return 'fimo/astro';
     }
-    // @vercel/frameworks reports SvelteKit as `sveltekit-1`, while Fimo's
-    // public runtime profile is `sveltekit`. Both describe the same codegen
-    // target; callers may supply either the detector evidence or the profile.
-    if (framework === 'sveltekit' || framework === 'sveltekit-1') {
+    if (framework === 'sveltekit') {
         return 'fimo/sveltekit';
     }
     return 'fimo/ui';

package/dist/scripts/validate-fimo-config.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { FimoAppConfigSchema } from '@fimo/api-contracts';
 import { resolveFimoConfigPath } from '../runtime/shared/fimo-config.server.js';
+import { validatePageRegistrySchemaReferences } from './validate-page-registry.js';
 export function validateFimoConfig(cwd) {
     const configPath = resolveFimoConfigPath(cwd);
     if (!fs.existsSync(configPath)) {
@@ -17,7 +18,10 @@ export function validateFimoConfig(cwd) {
     }
     const parsed = FimoAppConfigSchema.safeParse(value);
     if (parsed.success) {
-        return { errors: [], configChecked: true };
+        return {
+            errors: validatePageRegistrySchemaReferences(cwd, value, displayPath),
+            configChecked: true,
+        };
     }
     return {
         errors: parsed.error.issues.map((issue) => {

package/dist/scripts/validate-page-registry.d.ts

@@ -0,0 +1,2 @@
+/** Cross-check Page config references against the project's schema source files. */
+export declare function validatePageRegistrySchemaReferences(cwd: string, config: Record<string, unknown>, displayPath: string): string[];

package/dist/scripts/validate-page-registry.js

@@ -0,0 +1,167 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pageSourceParamExpressions, parsePageParamExpression, } from '@fimo/api-contracts';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function fieldList(value) {
+    if (typeof value === 'string') {
+        return [value];
+    }
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function queryFields(query) {
+    if (!isRecord(query)) {
+        return [];
+    }
+    const fields = new Set();
+    if (isRecord(query.where)) {
+        for (const field of Object.keys(query.where)) {
+            if (!field.startsWith('$')) {
+                fields.add(field.split('.')[0]);
+            }
+        }
+    }
+    for (const sort of fieldList(query.sort)) {
+        fields.add(sort.replace(/^-/, '').split('.')[0]);
+    }
+    for (const field of [...fieldList(query.fields), ...fieldList(query.populate)]) {
+        fields.add(field.split('.')[0]);
+    }
+    return [...fields];
+}
+function readSchemas(cwd) {
+    const directory = path.join(cwd, 'src/schemas');
+    if (!fs.existsSync(directory)) {
+        return null;
+    }
+    const schemas = new Map();
+    for (const file of fs.readdirSync(directory).filter((name) => name.endsWith('.json'))) {
+        const fallbackUid = path.basename(file, '.json');
+        let value;
+        try {
+            value = JSON.parse(fs.readFileSync(path.join(directory, file), 'utf8'));
+        }
+        catch {
+            schemas.set(fallbackUid, { fields: {}, isSingleton: false, valid: false });
+            continue;
+        }
+        if (!isRecord(value)) {
+            schemas.set(fallbackUid, { fields: {}, isSingleton: false, valid: false });
+            continue;
+        }
+        const uid = typeof value.uid === 'string' && value.uid ? value.uid : fallbackUid;
+        schemas.set(uid, {
+            fields: isRecord(value.fields) ? value.fields : {},
+            isSingleton: value.isSingleton === true,
+            valid: true,
+        });
+    }
+    return schemas;
+}
+function schemaFields(schema) {
+    return new Set([...Object.keys(schema.fields), 'id', 'slug']);
+}
+function queryableFields(schema) {
+    return new Set([...schemaFields(schema), 'createdAt', 'updatedAt']);
+}
+function validateQuery(query, pointer, schema, params, schemas) {
+    const errors = [];
+    const unknownField = queryFields(query).find((field) => !queryableFields(schema).has(field));
+    if (unknownField) {
+        errors.push(`${pointer}: Query field "${unknownField}" does not exist on the referenced schema.`);
+    }
+    for (const expression of pageSourceParamExpressions(query)) {
+        const parsed = parsePageParamExpression(expression);
+        const binding = parsed ? params[parsed.param] : undefined;
+        if (!parsed || !binding || typeof binding.schema !== 'string') {
+            continue;
+        }
+        const boundSchema = schemas.get(binding.schema);
+        const field = parsed.field.split('.')[0];
+        if (boundSchema?.valid && !schemaFields(boundSchema).has(field)) {
+            errors.push(`${pointer}: ${expression} reads missing field "${field}" from schema "${binding.schema}".`);
+        }
+    }
+    return errors;
+}
+/** Cross-check Page config references against the project's schema source files. */
+export function validatePageRegistrySchemaReferences(cwd, config, displayPath) {
+    const schemas = readSchemas(cwd);
+    if (!schemas || !isRecord(config.routes)) {
+        return [];
+    }
+    const errors = [];
+    for (const [routeId, rawRoute] of Object.entries(config.routes)) {
+        if (!isRecord(rawRoute)) {
+            continue;
+        }
+        const params = isRecord(rawRoute.params) ? rawRoute.params : {};
+        for (const [param, binding] of Object.entries(params)) {
+            const pointer = `${displayPath}#routes.${routeId}.params.${param}`;
+            if (typeof binding.schema !== 'string') {
+                continue;
+            }
+            const schema = schemas.get(binding.schema);
+            if (!schema) {
+                errors.push(`${pointer}.schema: Unknown schema "${binding.schema}".`);
+                continue;
+            }
+            if (!schema.valid) {
+                continue;
+            }
+            if (schema.isSingleton) {
+                errors.push(`${pointer}.schema: Page params require a Collection, but "${binding.schema}" is a Single.`);
+            }
+            const fields = schemaFields(schema);
+            for (const key of ['queryField', 'displayField']) {
+                const field = binding[key];
+                if (typeof field === 'string' && !fields.has(field)) {
+                    errors.push(`${pointer}.${key}: Field "${field}" does not exist on schema "${binding.schema}".`);
+                }
+            }
+            if (typeof binding.queryField === 'string' && !['id', 'slug'].includes(binding.queryField)) {
+                const definition = schema.fields[binding.queryField];
+                if (isRecord(definition)) {
+                    if (definition.required !== true) {
+                        errors.push(`${pointer}.queryField: Custom URL field "${binding.queryField}" must set "required": true.`);
+                    }
+                    if (definition.unique !== true) {
+                        errors.push(`${pointer}.queryField: Custom URL field "${binding.queryField}" must set "unique": true.`);
+                    }
+                }
+            }
+            errors.push(...validateQuery(binding.query, `${pointer}.query`, schema, params, schemas));
+        }
+        if (!isRecord(rawRoute.sources)) {
+            continue;
+        }
+        for (const [sourceName, source] of Object.entries(rawRoute.sources)) {
+            if (!isRecord(source) || (source.type !== 'single' && source.type !== 'collection')) {
+                continue;
+            }
+            const pointer = `${displayPath}#routes.${routeId}.sources.${sourceName}`;
+            if (typeof source.schema !== 'string') {
+                continue;
+            }
+            const schema = schemas.get(source.schema);
+            if (!schema) {
+                errors.push(`${pointer}.schema: Unknown schema "${source.schema}".`);
+                continue;
+            }
+            if (!schema.valid) {
+                continue;
+            }
+            if (source.type === 'single' && !schema.isSingleton) {
+                errors.push(`${pointer}.schema: Source expects a Single, but "${source.schema}" is a Collection.`);
+            }
+            if (source.type === 'collection' && schema.isSingleton) {
+                errors.push(`${pointer}.schema: Source expects a Collection, but "${source.schema}" is a Single.`);
+            }
+            if (source.type === 'collection') {
+                errors.push(...validateQuery(source.query, `${pointer}.query`, schema, params, schemas));
+            }
+        }
+    }
+    return errors;
+}