fimo 0.6.0 → 0.7.0-experimental.2

package/dist/runtime/content/client/createContentClient.d.ts

@@ -0,0 +1,5 @@
+import type { CollectionContentClient, ContentClientConfig } from './types.js';
+export declare function createContentClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig): CollectionContentClient<T, TInput>;
+//# sourceMappingURL=createContentClient.d.ts.map

package/dist/runtime/content/client/createContentClient.js

@@ -0,0 +1,300 @@
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { parseCollectionResponse } from '../parseCollectionResponse.js';
+import { apiBase, buildReadPath, fimoHeaders, interpretSchema, readCollectionLocale, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
+import { useQueryLocale } from './useQueryLocale.js';
+export function createContentClient(config) {
+    const references = config.references ?? {};
+    const info = interpretSchema(config.schema);
+    if (info.isSingleton) {
+        throw new Error(`Schema "${info.uid}" is a singleton — use createSingletonClient instead.`);
+    }
+    validateReferences(info, references);
+    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
+    const self = { wrapWithSource, meta };
+    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
+    function wrapWithSource(entry) {
+        return wrapEntry(info, entry, { alwaysIncludeLocale: true, resolve });
+    }
+    function readPath(url, options) {
+        return buildReadPath(url, readCollectionLocale(options), options.populate, options.localeFallbacks);
+    }
+    async function getById(id, options = {}) {
+        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/${id}`, options)}`, {
+            headers: fimoHeaders(),
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    async function getBySlug(slug, options = {}) {
+        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/slug/${encodeURIComponent(slug)}`, options)}`, { headers: fimoHeaders() });
+        if (res.status === 404) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    async function getByField(fieldName, value, options = {}) {
+        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/field/${encodeURIComponent(fieldName)}/${encodeURIComponent(value)}`, options)}`, { headers: fimoHeaders() });
+        if (res.status === 404) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    function toQueryString(params) {
+        const { where, sort, fields, populate, locale: requestedLocale, ...flat } = params;
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(flat)) {
+            if (value == null) {
+                continue;
+            }
+            query.set(key, String(value));
+        }
+        if (sort != null) {
+            query.set('sort', Array.isArray(sort) ? sort.join(',') : String(sort));
+        }
+        if (fields != null) {
+            query.set('fields', typeof fields === 'string' ? fields : fields.join(','));
+        }
+        if (populate != null) {
+            query.set('populate', typeof populate === 'string' ? populate : populate.join(','));
+        }
+        if (where && Object.keys(where).length > 0) {
+            query.set('where', JSON.stringify(where));
+        }
+        const locale = readCollectionLocale({ locale: requestedLocale });
+        if (locale) {
+            query.set('locale', locale);
+        }
+        return query.toString();
+    }
+    async function list(params = {}) {
+        const qs = toQueryString(params);
+        const res = await fetch(`${apiBase()}/entries/${info.uid}${qs ? '?' + qs : ''}`, {
+            headers: fimoHeaders(),
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = parseCollectionResponse(await res.json());
+        const items = data.data.map(wrapWithSource);
+        const pageInfo = {
+            limit: data.meta.limit,
+            offset: data.meta.offset,
+            total: data.meta.total,
+            hasMore: data.meta.hasMore,
+            nextOffset: data.meta.hasMore ? data.meta.offset + data.meta.limit : null,
+        };
+        return { items, pageInfo };
+    }
+    async function get(params = {}) {
+        return (await list(params)).items;
+    }
+    async function create(payload) {
+        const res = await fetch(`${apiBase()}/entries/${info.uid}`, {
+            method: 'POST',
+            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify(splitWritePayload(payload)),
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    async function update(id, payload) {
+        const write = splitWritePayload(payload);
+        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale({ locale: write.locale }), undefined);
+        const res = await fetch(`${apiBase()}${url}`, {
+            method: 'PUT',
+            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({ data: write.data }),
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    async function remove(id, options = {}) {
+        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale(options), undefined);
+        const res = await fetch(`${apiBase()}${url}`, { method: 'DELETE', headers: fimoHeaders() });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+    }
+    const qk = {
+        root: [info.pascal],
+        byId: (id, options = {}) => [info.pascal, 'id', id, options.locale, options.populate],
+        bySlug: (slug, options = {}) => [info.pascal, 'slug', slug, options.locale, options.populate],
+        byField: (field, value, options = {}) => [info.pascal, field, value, options.locale, options.populate],
+        list: (params) => [info.pascal, params],
+        infiniteList: (params) => [info.pascal, 'infinite', params],
+    };
+    function useGetById(id, options = {}) {
+        const locale = useQueryLocale(options.locale);
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: qk.byId(id, localizedOptions),
+            queryFn: () => getById(id, localizedOptions),
+        });
+    }
+    function useGetBySlug(slug, options = {}) {
+        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: qk.bySlug(slug, localizedOptions),
+            queryFn: () => getBySlug(slug, localizedOptions),
+            enabled: !!slug,
+        });
+    }
+    function useGetByField(fieldName, value, options = {}) {
+        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: qk.byField(fieldName, value, localizedOptions),
+            queryFn: () => getByField(fieldName, value, localizedOptions),
+            enabled: !!value,
+        });
+    }
+    function useGet(params = {}) {
+        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        return useQuery({
+            queryKey: qk.list(localizedParams),
+            queryFn: () => list(localizedParams),
+            select: (page) => page.items,
+        });
+    }
+    function useList(params = {}) {
+        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        return useQuery({
+            queryKey: qk.list(localizedParams),
+            queryFn: () => list(localizedParams),
+        });
+    }
+    function useInfiniteList(params = {}) {
+        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        const query = useInfiniteQuery({
+            queryKey: qk.infiniteList(localizedParams),
+            queryFn: ({ pageParam }) => list({ ...localizedParams, offset: pageParam }),
+            initialPageParam: 0,
+            getNextPageParam: (lastPage) => lastPage.pageInfo.nextOffset ?? undefined,
+        });
+        return {
+            ...query,
+            items: query.data?.pages.flatMap((page) => page.items) ?? [],
+            total: query.data?.pages[0]?.pageInfo.total ?? 0,
+            hasMore: query.hasNextPage,
+            loadMore: () => query.fetchNextPage(),
+            isLoadingMore: query.isFetchingNextPage,
+        };
+    }
+    function useSuspenseGetById(id, options = {}) {
+        const locale = useQueryLocale(options.locale);
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: qk.byId(id, localizedOptions),
+            queryFn: () => getById(id, localizedOptions),
+        });
+    }
+    function useSuspenseGetBySlug(slug, options = {}) {
+        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: qk.bySlug(slug, localizedOptions),
+            queryFn: () => getBySlug(slug, localizedOptions),
+        });
+    }
+    function useSuspenseGetByField(fieldName, value, options = {}) {
+        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: qk.byField(fieldName, value, localizedOptions),
+            queryFn: () => getByField(fieldName, value, localizedOptions),
+        });
+    }
+    function useSuspenseGet(params = {}) {
+        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        return useSuspenseQuery({
+            queryKey: qk.list(localizedParams),
+            queryFn: () => list(localizedParams),
+            select: (page) => page.items,
+        });
+    }
+    function useCreate() {
+        const qc = useQueryClient();
+        const activeLocale = useQueryLocale();
+        return useMutation({
+            mutationFn: (payload) => create(withMutationLocale(payload, activeLocale)),
+            onSuccess: () => qc.invalidateQueries({ queryKey: qk.root }),
+        });
+    }
+    function useUpdate() {
+        const qc = useQueryClient();
+        const activeLocale = useQueryLocale();
+        return useMutation({
+            mutationFn: ({ id, ...patch }) => update(id, withMutationLocale(patch, activeLocale)),
+            onSuccess: (_data, vars) => {
+                qc.invalidateQueries({ queryKey: qk.root });
+                qc.invalidateQueries({ queryKey: qk.byId(vars.id, { locale: vars.locale ?? activeLocale }) });
+            },
+        });
+    }
+    function useRemove() {
+        const qc = useQueryClient();
+        const activeLocale = useQueryLocale();
+        return useMutation({
+            mutationFn: (value) => {
+                const { id, locale } = typeof value === 'string'
+                    ? { id: value, locale: activeLocale }
+                    : { ...value, locale: value.locale ?? activeLocale };
+                return remove(id, { locale });
+            },
+            onSuccess: (_data, value) => {
+                const { id, locale } = typeof value === 'string'
+                    ? { id: value, locale: activeLocale }
+                    : { ...value, locale: value.locale ?? activeLocale };
+                qc.invalidateQueries({ queryKey: qk.root });
+                qc.removeQueries({ queryKey: qk.byId(id, { locale }), exact: false });
+            },
+        });
+    }
+    return {
+        meta,
+        wrapWithSource,
+        getById,
+        getBySlug,
+        getByField,
+        list,
+        get,
+        create,
+        update,
+        remove,
+        useGetById,
+        useGetBySlug,
+        useGetByField,
+        useGet,
+        useList,
+        useInfiniteList,
+        useSuspenseGetById,
+        useSuspenseGetBySlug,
+        useSuspenseGetByField,
+        useSuspenseGet,
+        useCreate,
+        useUpdate,
+        useRemove,
+    };
+}

package/dist/runtime/content/client/createSingletonClient.d.ts

@@ -0,0 +1,5 @@
+import type { ContentClientConfig, SingletonContentClient } from './types.js';
+export declare function createSingletonClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig): SingletonContentClient<T, TInput>;
+//# sourceMappingURL=createSingletonClient.d.ts.map

package/dist/runtime/content/client/createSingletonClient.js

@@ -0,0 +1,108 @@
+import { useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { apiBase, buildReadPath, fimoHeaders, interpretSchema, readSingletonLocale, referenceTargetUids, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
+import { useQueryLocale } from './useQueryLocale.js';
+export function createSingletonClient(config) {
+    const references = config.references ?? {};
+    const info = interpretSchema(config.schema);
+    if (!info.isSingleton) {
+        throw new Error(`Schema "${info.uid}" is a collection — use createContentClient instead.`);
+    }
+    validateReferences(info, references);
+    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
+    const self = { wrapWithSource, meta };
+    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
+    // Which reference fields point at a localized schema decides whether a
+    // non-localized singleton read must still send a locale. Target metas live
+    // on other modules in a possibly-cyclic graph, so this is derived lazily on
+    // first request, never at module init.
+    let localizedReferenceFields = null;
+    function getLocalizedReferenceFields() {
+        if (localizedReferenceFields) {
+            return localizedReferenceFields;
+        }
+        const fields = new Set();
+        for (const [key, field] of info.fields) {
+            if (field.type !== 'reference') {
+                continue;
+            }
+            const localizedTarget = referenceTargetUids(field).some((uid) => resolve(uid)?.meta?.localized !== false);
+            if (localizedTarget) {
+                fields.add(key);
+            }
+        }
+        localizedReferenceFields = fields;
+        return fields;
+    }
+    function wrapWithSource(entry) {
+        return wrapEntry(info, entry, { alwaysIncludeLocale: info.localized, resolve });
+    }
+    function readLocale(options, fallbackLocale) {
+        return fallbackLocale === undefined
+            ? readSingletonLocale(options, info.localized, getLocalizedReferenceFields())
+            : readSingletonLocale(options, info.localized, getLocalizedReferenceFields(), fallbackLocale);
+    }
+    function readPath(url, options) {
+        return buildReadPath(url, readLocale(options), options.populate, options.localeFallbacks);
+    }
+    async function get(options = {}) {
+        const res = await fetch(`${apiBase()}${readPath(`/documents/${info.uid}`, options)}`, {
+            headers: fimoHeaders(),
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    async function update(payload) {
+        const write = splitWritePayload(payload);
+        const url = buildReadPath(`/documents/${info.uid}`, readLocale({ locale: write.locale }), undefined);
+        const res = await fetch(`${apiBase()}${url}`, {
+            method: 'PUT',
+            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({ data: write.data }),
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        const data = await res.json();
+        return wrapWithSource(data.data);
+    }
+    const qk = {
+        root: [info.pascal],
+        document: (options = {}) => [info.pascal, 'document', options.locale, options.populate],
+    };
+    function useGet(options = {}) {
+        const locale = readLocale(options, useQueryLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: qk.document(localizedOptions),
+            queryFn: () => get(localizedOptions),
+        });
+    }
+    function useSuspenseGet(options = {}) {
+        const locale = readLocale(options, useQueryLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: qk.document(localizedOptions),
+            queryFn: () => get(localizedOptions),
+        });
+    }
+    function useUpdate() {
+        const qc = useQueryClient();
+        const activeLocale = useQueryLocale();
+        return useMutation({
+            mutationFn: (payload) => update(withMutationLocale(payload, activeLocale)),
+            onSuccess: () => qc.invalidateQueries({ queryKey: qk.root }),
+        });
+    }
+    return {
+        meta,
+        wrapWithSource,
+        get,
+        update,
+        useGet,
+        useSuspenseGet,
+        useUpdate,
+    };
+}

package/dist/runtime/content/client/internal.d.ts

@@ -0,0 +1,44 @@
+import type { ContentClientHandle, ContentModuleRef, ContentSchema, ContentSchemaField } from './types.js';
+export interface InterpretedSchema {
+    uid: string;
+    pascal: string;
+    localized: boolean;
+    isSingleton: boolean;
+    fields: ReadonlyArray<readonly [string, ContentSchemaField]>;
+}
+export declare function interpretSchema(schema: ContentSchema): InterpretedSchema;
+export declare function referenceTargetUids(field: ContentSchemaField): readonly string[];
+export declare function validateReferences(info: InterpretedSchema, references: Readonly<Record<string, ContentModuleRef>>): void;
+export declare function apiBase(): string;
+export declare function defaultLocale(): string;
+export declare function fimoHeaders(extra?: Record<string, string>): Record<string, string>;
+interface LocaleReadOptions {
+    locale?: string;
+    populate?: string | readonly string[];
+}
+export declare function readCollectionLocale(options: LocaleReadOptions, fallbackLocale?: string): string;
+export declare function readSingletonLocale(options: LocaleReadOptions, ownerUsesLocale: boolean, localizedReferenceFields: ReadonlySet<string>, fallbackLocale?: string): string | undefined;
+export declare function buildReadPath(url: string, locale: string | undefined, populate: string | readonly string[] | undefined, localeFallbacks?: boolean): string;
+export declare function splitWritePayload(payload: Record<string, unknown>): {
+    data: Record<string, unknown>;
+    locale?: string;
+    documentId?: string;
+};
+export declare function withMutationLocale<T extends object>(payload: T, activeLocale: string): T & {
+    locale: string;
+};
+type ReferenceResolver = (uid: string) => ContentClientHandle | undefined;
+/**
+ * A reference is either a client or a module namespace whose default export
+ * is the client. Only ever called at request time — unwrapping a namespace's
+ * `default` mid-cycle would read an uninitialized binding. A namespace can
+ * plausibly carry BOTH a re-exported wrapWithSource and a default client, so
+ * prefer whichever shape carries meta — the locale rules depend on it.
+ */
+export declare function resolveClientHandle(ref: ContentModuleRef | undefined): ContentClientHandle | undefined;
+export declare function wrapEntry(info: InterpretedSchema, entry: Record<string, any>, options: {
+    alwaysIncludeLocale: boolean;
+    resolve: ReferenceResolver;
+}): Record<string, unknown>;
+export {};
+//# sourceMappingURL=internal.d.ts.map